大数据之Spark案例实操完整使用

  • 一、案例一
    • 1、准备数据
    • 2、需求 1：Top10 热门品类
    • 3、需求说明
      • 方案一、
      • 实现方案二
      • 实现方案三
  • 二 、需求实现
    • 1、需求 2：Top10 热门品类中每个品类的 Top10 活跃 Session 统计
    • 2、页面单跳转换率统计
  • 三、工程代码三层架构
    • 1、三层介绍
    • 2、结构图
    • 3、代码

一、案例一

1、准备数据


上面的数据图是从数据文件中截取的一部分内容，表示为电商网站的用户行为数据，主要包含用户的 4 种行为：搜索，点击，下单，支付。数据规则如下：

➢ 数据文件中每行数据采用下划线分隔数据

➢ 每一行数据表示用户的一次行为，这个行为只能是 4 种行为的一种

➢ 如果搜索关键字为 null,表示数据不是搜索数据

➢ 如果点击的品类 ID 和产品 ID 为-1，表示数据不是点击数据

➢ 针对于下单行为，一次可以下单多个商品，所以品类 ID 和产品 ID 可以是多个，id 之间采用逗号分隔，如果本次不是下单行为，则数据采用 null 表示

➢ 支付行为和下单行为类似

详细字段说明

编号 字段名称 字段类型 字段含义
1 date String 用户点击行为的日期
2 user_id Long 用户的 ID
3 session_id String Session 的 ID
4 page_id Long 某个页面的 ID
5 action_time String 动作的时间点
6 search_keyword String 用户搜索的关键词
7 click_category_id Long 某一个商品品类的 ID
8 click_product_id Long 某一个商品的 ID
9 order_category_ids String 一次订单中所有品类的 ID 集合
10 order_product_ids String 一次订单中所有商品的 ID 集合
11 pay_category_ids String 一次支付中所有品类的 ID 集合
12 pay_product_ids String 一次支付中所有商品的 ID 集合
13 city_id Long 城市 id 
//用户访问动作表
case class UserVisitAction(date: String,//用户点击行为的日期user_id: Long,//用户的 IDsession_id: String,//Session 的 IDpage_id: Long,//某个页面的 IDaction_time: String,//动作的时间点search_keyword: String,//用户搜索的关键词click_category_id: Long,//某一个商品品类的 IDclick_product_id: Long,//某一个商品的 IDorder_category_ids: String,//一次订单中所有品类的 ID 集合order_product_ids: String,//一次订单中所有商品的 ID 集合pay_category_ids: String,//一次支付中所有品类的 ID 集合pay_product_ids: String,//一次支付中所有商品的 ID 集合city_id: Long
)//城市 id

2、需求 1：Top10 热门品类

3、需求说明

品类是指产品的分类，大型电商网站品类分多级，咱们的项目中品类只有一级，不同的
公司可能对热门的定义不一样。我们按照每个品类的点击、下单、支付的量来统计热门品类。

鞋 点击数 下单数 支付数
衣服 点击数 下单数 支付数
电脑 点击数 下单数 支付数
例如，综合排名 = 点击数20%+下单数30%+支付数*50%
本项目需求优化为：先按照点击数排名，靠前的就排名高；如果点击数相同，再比较下 单数；下单数再相同，就比较支付数。

方案一、

分别统计每个品类点击的次数，下单的次数和支付的次数：
（品类，点击总数）（品类，下单总数）（品类，支付总数）

package com.spack.bigdata.core.reqimport org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}object Spark01_Req1_HotCategoryTop10Analysis {def main(args: Array[String]): Unit = {/**** TODO 热门类品类*/val operator = new SparkConf().setMaster("local[*]").setAppName("HotCategoryTop10Analysis")val sc = new SparkContext(operator)//TODO 1、读取原始日志数据val actionRdd: RDD[String] = sc.textFile("datas/user_visit_action.txt")//TODO 2、统计品类的点击数量：（品类ID,点击数量）val clickActionRDD = actionRdd.filter(action => {val datas = action.split("_")//获取索引6的、去除不是-1的数据datas(6) != "-1"})val clickCountRDD: RDD[(String, Int)] = clickActionRDD.map(action => {val datas = action.split("_")//点击品类的ID就有了、数量就是1--(单独统计点击的品类)(datas(6), 1)}).reduceByKey(_ + _)//TODO 3、统计品类的下单数量：（品类ID,下单数量） ----下单的话一定不为nullval orderCountRDD = actionRdd.filter(action => {val datas = action.split("_")//获取索引6的、去除不是-1的数据datas(8) != "null"})val orderCount: RDD[(String, Int)] = orderCountRDD.flatMap(action => {val datas = action.split("_")val cid = datas(8)val cids = cid.split(",")cids.map(id => (id, 1))}).reduceByKey(_ + _)//    value".collect().foreach(println)//TODO 4、统计品类的支付数量：（品类ID,支付数量）val payCountRDD = actionRdd.filter(action => {val datas = action.split("_")//获取索引6的、去除不是-1的数据datas(10) != "null"})val payCount: RDD[(String, Int)] = payCountRDD.flatMap(action => {val datas = action.split("_")val cid = datas(10)val cids = cid.split(",")cids.map(id => (id, 1))}).reduceByKey(_ + _)//TODO 5、将品类进行排序，并且提取前十名//点击数量排序、下单数量排序，支付数量排序//元组排序：先比较第一个，在比较第二个，在比较第三个，以此类推退//（品类ID,(点击数量,下单数量，支付数量)）//会在自己的数据源建立一个分组、跟另外一个数据源做一个链接//cogroup = connect + groupval cogroupRDD: RDD[(String, (Iterable[Int], Iterable[Int], Iterable[Int]))] = clickCountRDD.cogroup(orderCount, payCount)val analysisRDD = cogroupRDD.mapValues {case (clickIter, orderIter, payIter) => {var clickCnt = 0val iter1 = clickIter.iteratorif (iter1.hasNext) {clickCnt = iter1.next()}var orderCnt = 0val iter2 = orderIter.iteratorif (iter2.hasNext) {orderCnt = iter2.next()}var payCnt = 0val iter3 = payIter.iteratorif (iter3.hasNext) {payCnt = iter3.next()}(clickCnt, orderCnt, payCnt)}}val tuples = analysisRDD.sortBy(_._2, false).take(10)tuples.foreach(println)//TODO 6、将结果采集到控制台打印出来sc.stop()//TODO 7、统计品类的点击数量：（品类ID,点击数量）}}

结果：
(15,(6120,1672,1259))
(2,(6119,1767,1196))
(20,(6098,1776,1244))
(12,(6095,1740,1218))
(11,(6093,1781,1202))
(17,(6079,1752,1231))
(7,(6074,1796,1252))
(9,(6045,1736,1230))
(19,(6044,1722,1158))
(13,(6036,1781,1161))

实现方案二

一次性统计每个品类点击的次数，下单的次数和支付的次数：
（品类，（点击总数，下单总数，支付总数））

package com.spack.bigdata.core.reqimport org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}/*** 第二种实现方式*/
object Spark02_Req1_HotCategoryTop10Analysis {def main(args: Array[String]): Unit = {/**** TODO 热门类品类*/val operator = new SparkConf().setMaster("local[*]").setAppName("HotCategoryTop10Analysis")val sc = new SparkContext(operator)//Q: actionRdd重复使用 -使用缓存//Q: cogroup性能可能较低//TODO 1、读取原始日志数据val actionRdd: RDD[String] = sc.textFile("datas/user_visit_action.txt")actionRdd.cache()//TODO 2、统计品类的点击数量：（品类ID,点击数量）val clickActionRDD = actionRdd.filter(action => {val datas = action.split("_")//获取索引6的、去除不是-1的数据datas(6) != "-1"})val clickCountRDD: RDD[(String, Int)] = clickActionRDD.map(action => {val datas = action.split("_")//点击品类的ID就有了、数量就是1--(单独统计点击的品类)(datas(6), 1)}).reduceByKey(_ + _)//TODO 3、统计品类的下单数量：（品类ID,下单数量） ----下单的话一定不为nullval orderCountRDD = actionRdd.filter(action => {val datas = action.split("_")//获取索引6的、去除不是-1的数据datas(8) != "null"})val orderCount: RDD[(String, Int)] = orderCountRDD.flatMap(action => {val datas = action.split("_")val cid = datas(8)val cids = cid.split(",")cids.map(id => (id, 1))}).reduceByKey(_ + _)//    value".collect().foreach(println)//TODO 4、统计品类的支付数量：（品类ID,支付数量）val payCountRDD = actionRdd.filter(action => {val datas = action.split("_")//获取索引6的、去除不是-1的数据datas(10) != "null"})val payCount: RDD[(String, Int)] = payCountRDD.flatMap(action => {val datas = action.split("_")val cid = datas(10)val cids = cid.split(",")cids.map(id => (id, 1))}).reduceByKey(_ + _)//TODO 5、将品类进行排序，并且提取前十名//点击数量排序、下单数量排序，支付数量排序//元组排序：先比较第一个，在比较第二个，在比较第三个，以此类推退//（品类ID,(点击数量,下单数量，支付数量)）//会在自己的数据源建立一个分组、跟另外一个数据源做一个链接//cogroup = connect + groupval rdd = clickCountRDD.map {case (cid, cnt) => {(cid, (cnt, 0, 0))}}val rdd1 = orderCount.map {case (cid, cnt) => {(cid, (0, cnt, 0))}}val rdd2 = payCount.map {case (cid, cnt) => {(cid, (0, 0, cnt))}}//将三个数据源合并在一起、统一进行聚合计算val sourceRDD: RDD[(String, (Int, Int, Int))] = rdd.union(rdd1).union(rdd2)val analysisRDD = sourceRDD.reduceByKey {(t1, t2) => {(t1._1+t2._1,t1._2+ t2._2,t1._3+ t2._3)}}
//        sourceRDD.collect().foreach(println)val tuples = analysisRDD.sortBy(_._2, false).take(10)tuples.foreach(println)//TODO 6、将结果采集到控制台打印出来sc.stop()//TODO 7、统计品类的点击数量：（品类ID,点击数量）}}

结果：
(15,(6120,1672,1259))
(2,(6119,1767,1196))
(20,(6098,1776,1244))
(12,(6095,1740,1218))
(11,(6093,1781,1202))
(17,(6079,1752,1231))
(7,(6074,1796,1252))
(9,(6045,1736,1230))
(19,(6044,1722,1158))
(13,(6036,1781,1161))

Process finished with exit code 0

实现方案三

使用累加器的方式聚合数据

package com.spack.bigdata.core.reqimport org.apache.spark.rdd.RDD
import org.apache.spark.util.AccumulatorV2
import org.apache.spark.{SparkConf, SparkContext}import scala.collection.mutable/*** 使用累加器的方式聚合数据**/
object Spark04_Req1_HotCategoryTop10Analysis {def main(args: Array[String]): Unit = {/**** TODO 热门类品类*/val operator = new SparkConf().setMaster("local[*]").setAppName("HotCategoryTop10Analysis")val sc = new SparkContext(operator)//TODO 1、读取原始日志数据val actionRdd: RDD[String] = sc.textFile("datas/user_visit_action.txt")val acc = new HotCategoryAccumulatorsc.register(acc, "HotCategory")//将数据转换结构val flatMapRDD = actionRdd.foreach(action => {val datas = action.split("_")if (datas(6) != "-1") {//点击的场合acc.add(datas(6), "click")} else if (datas(8) != "null") {//下单的场合val ids = datas(8).split(",")ids.foreach(id => {acc.add(id, "order")})} else if (datas(10) != "null") {//支付的场合val ids = datas(10).split(",")ids.foreach(id => {acc.add(id, "pay")})}})val accVal: mutable.Map[String, HotCategory] = acc.valueval categories: mutable.Iterable[HotCategory] = accVal.map(_._2)val sort = categories.toList.sortWith((left, right) => {if (left.clickCnt > right.clickCnt) {true} else if (left.clickCnt == right.clickCnt) {if (left.orderCnt > right.orderCnt) {true} else if (left.orderCnt == right.orderCnt) {left.payCnt > right.payCnt} else {false}} else {false}})sort.take(10).foreach(println)//TODO 6、将结果采集到控制台打印出来sc.stop()//TODO 7、统计品类的点击数量：（品类ID,点击数量）}case class HotCategory(cid: String, var clickCnt: Int, var orderCnt: Int, var payCnt: Int)/*** 自定义累加器* 1、继承AccumlatorV2,定义泛型* IN :(品类ID,行为类型)* OUT: mutable.Map[String,HotCategory]** 2、重写方法（6）*/class HotCategoryAccumulator extends AccumulatorV2[(String, String), mutable.Map[String, HotCategory]] {private val hcMap = mutable.Map[String, HotCategory]()//是不是当前的初始状态override def isZero: Boolean = {hcMap.isEmpty}override def copy(): AccumulatorV2[(String, String), mutable.Map[String, HotCategory]] = {new HotCategoryAccumulator()}override def reset(): Unit = {hcMap.clear()}override def add(v: (String, String)): Unit = {val cid = v._1val actionType = v._2val category: HotCategory = hcMap.getOrElse(cid, HotCategory(cid, 0, 0, 0))if (actionType == "click") {category.clickCnt += 1} else if (actionType == "order") {category.orderCnt += 1} else if (actionType == "pay") {category.payCnt += 1}hcMap.update(cid, category)}override def merge(other: AccumulatorV2[(String, String), mutable.Map[String, HotCategory]]): Unit = {val map1 = this.hcMapval map2 = other.valuemap2.foreach {case (cid, hc) => {val category: HotCategory = map1.getOrElse(cid, HotCategory(cid, 0, 0, 0))category.clickCnt += hc.clickCntcategory.orderCnt += hc.orderCntcategory.payCnt += hc.payCntmap1.update(cid, category)}}}//返回结果override def value: mutable.Map[String, HotCategory] = hcMap}
}

二 、需求实现

1、需求 2：Top10 热门品类中每个品类的 Top10 活跃 Session 统计

需求说明：
在需求一的基础上，增加每个品类用户 session 的点击统计

package com.spack.bigdata.core.reqimport org.apache.spark.rdd.RDD
import org.apache.spark.util.AccumulatorV2
import org.apache.spark.{SparkConf, SparkContext}import scala.collection.mutable/*** 第三种实现方式* 重新看- 没看懂**/
object Spark05_Req1_HotCategoryTop10Analysis {def main(args: Array[String]): Unit = {/**** TODO 热门类品类*/val operator = new SparkConf().setMaster("local[*]").setAppName("HotCategoryTop10Analysis")val sc = new SparkContext(operator)val actionRdd: RDD[String] = sc.textFile("datas/user_visit_action.txt")actionRdd.cache()val top10Ids: Array[(String)] = top10Category(actionRdd)//1、过滤原始数据、保留点击和前10品类IDval filterActionRDD = actionRdd.filter(action => {val datas = action.split("_")//先满足这个条件if (datas(6) != "-1") {//判断datas(6) 在不在 top10Ids 里面top10Ids.contains(datas(6))} else {false}})//根据品类ID和sessionID进行点击量的统计val reduceRDD = filterActionRDD.map(action => {val datas = action.split("_")((datas(6), datas(2)), 1)}).reduceByKey(_ + _)//3、将统计数据的结果进行结构的转换//（（品类ID,sessionID）,sum）=>(品类ID,(SessionID,sum))val mapRDD = reduceRDD.map {case ((cid, sid), sum) => {(cid, (sid, sum))}}//相同的品类进行分组val groupRDD: RDD[(String, Iterable[(String, Int)])] = mapRDD.groupByKey()//5、将分组后的数据进行点击量的排序、取前10名val resultRDD = groupRDD.mapValues(iter => {iter.toList.sortBy(_._2)(Ordering.Int.reverse).take(10)})resultRDD.collect().foreach(println)sc.stop()}def top10Category(actionRdd: RDD[String]): Array[(String)] = {val flatRDD: RDD[(String, (Int, Int, Int))] = actionRdd.flatMap(action => {val datas = action.split("_")if (datas(6) != "-1") {//点击的场合List((datas(6), (1, 0, 0)))} else if (datas(8) != "null") {//下单的场合val ids = datas(8).split(",")ids.map(id => (id, (0, 1, 0)))} else if (datas(10) != "null") {//支付的场合val ids = datas(10).split(",")ids.map(id => (id, (0, 0, 1)))} else {Nil}})val analysisRDD: RDD[(String, (Int, Int, Int))] = flatRDD.reduceByKey((t1, t2) => {(t1._1 + t2._1, t1._2 + t2._2, t1._3 + t2._3)})analysisRDD.sortBy(_._2, false).take(10).map(_._1)}}

2、页面单跳转换率统计

需求说明
1）页面单跳转化率
计算页面单跳转化率，什么是页面单跳转换率，比如一个用户在一次 Session 过程中
访问的页面路径 3,5,7,9,10,21，那么页面 3 跳到页面 5 叫一次单跳，7-9 也叫一次单跳，
那么单跳转化率就是要统计页面点击的概率。
比如：计算 3-5 的单跳转化率，先获取符合条件的 Session 对于页面 3 的访问次数（PV） 为 A，然后获取符合条件的 Session 中访问了页面 3 又紧接着访问了页面 5 的次数为 B，
那么 B/A 就是 3-5 的页面单跳转化率。

2）统计页面单跳转化率意义
产品经理和运营总监，可以根据这个指标，去尝试分析，整个网站，产品，各个页面的
表现怎么样，是不是需要去优化产品的布局；吸引用户最终可以进入最后的支付页面。
数据分析师，可以此数据做更深一步的计算和分析。
企业管理层，可以看到整个公司的网站，各个页面的之间的跳转的表现如何，可以适当
调整公司的经营战略或策略。

package com.spack.bigdata.core.reqimport org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}/*** 第三种实现方式* 重新看- 没看懂**/
object Spark06_Req3_HotCategoryTop10Analysis {def main(args: Array[String]): Unit = {/**** TODO 热门类品类*/val operator = new SparkConf().setMaster("local[*]").setAppName("HotCategoryTop10Analysis")val sc = new SparkContext(operator)val actionRdd: RDD[String] = sc.textFile("datas/user_visit_action.txt")val actionDataRdd: RDD[UserVisitAction] = actionRdd.map(action => {val datas = action.split("_")UserVisitAction(datas(0),datas(1).toLong,datas(2),datas(3).toLong,datas(4),datas(5),datas(6).toLong,datas(7).toLong,datas(8),datas(9),datas(10),datas(11),datas(12).toLong,)})//TODO 对指定的页面连续跳转进行统计//1-2,2-3,3-4,4-5,5-6,6-7val ids = List[Long](1, 2, 3, 4, 5, 6, 7)val okflowIds: List[(Long, Long)] = ids.zip(ids.tail)//TODO 计算分母 --求首页val pageidToCountMap: Map[Long, Long] = actionDataRdd.filter(//先过滤提高  ---init 不包含最后一个action => {ids.init.contains(action.page_id)}).map(action => {(action.page_id, 1L)}).reduceByKey(_ + _).collect().toMapactionDataRdd.cache()//TODO 计算分子val sessionRDD: RDD[(String, Iterable[UserVisitAction])] = actionDataRdd.groupBy(_.session_id)//分组后、根据访问时间进行排序(升序)val mvRdd: RDD[(String, List[((Long, Long), Int)])] = sessionRDD.mapValues(iter => {val sortList: List[UserVisitAction] = iter.toList.sortBy(_.action_time) //默认升序//[1,2,3,4]//[1,2] ,[2,3],[3,4]//[1-2,2-3,3-4]//Sliding:滑窗//【1，2，3，4】 flowIds就是【1，2，3，4】//【2，3，4】 就是 List[Long] 尾部信息//        zip 拉链val flowIds: List[Long] = sortList.map(_.page_id)val pageFlowIds: List[(Long, Long)] = flowIds.zip(flowIds.tail)//将不合法的页面跳转进行过滤pageFlowIds.filter(t => {okflowIds.contains(t)}).map(t => {(t, 1)})})//((1,2),1) 拆开val flatRDD: RDD[((Long, Long), Int)] = mvRdd.map(_._2).flatMap(list => list)//((1,2),1)=>((1,2),SUM)val dataRDD = flatRDD.reduceByKey(_ + _)//TODO 计算单挑转换率//分子除以分母dataRDD.foreach {case ((pageid1, pageid2), sum) => {val lon: Long = pageidToCountMap.getOrElse(pageid1, 0L)println(s"页面${pageid1}挑转到页面${pageid2}单挑转化率为" + (sum.toDouble / lon))}}sc.stop()}//用户访问动作表case class UserVisitAction(date: String, //用户点击行为的日期user_id: Long, //用户的 IDsession_id: String, //Session 的 IDpage_id: Long, //某个页面的 IDaction_time: String, //动作的时间点search_keyword: String, //用户搜索的关键词click_category_id: Long, //某一个商品品类的 IDclick_product_id: Long, //某一个商品的 IDorder_category_ids: String, //一次订单中所有品类的 ID 集合order_product_ids: String, //一次订单中所有商品的 ID 集合pay_category_ids: String, //一次支付中所有品类的 ID 集合pay_product_ids: String, //一次支付中所有商品的 ID 集合city_id: Long) //城市 id
}

三、工程代码三层架构

1、三层介绍

2、结构图

3、代码

application包

package com.spack.bigdata.core.framework.applicationimport com.spack.bigdata.core.framework.common.TApplication
import com.spack.bigdata.core.framework.controller.WordCountControllerobject WordCountApplication extends App with TApplication {//启动应用程序start() {val controller = new WordCountController()controller.dispatch()}}

controller包

package com.spack.bigdata.core.framework.controllerimport com.spack.bigdata.core.framework.common.TController
import com.spack.bigdata.core.framework.service.WordCountService/*** 控制层*/
class WordCountController extends  TController{private val wordCountService = new WordCountService()//调度def dispatch(): Unit = {//TODO 执行业务逻辑val array = wordCountService.dataAnalysis()array.foreach(println)}}

dao包

package com.spack.bigdata.core.framework.daoimport com.spack.bigdata.core.framework.common.TDaoclass WordCountDao extends TDao{//
//
//  def readFile(path: String) = {//     sc.textFile("datas")
//  }
}

service包

package com.spack.bigdata.core.framework.serviceimport com.spack.bigdata.core.framework.common.TService
import com.spack.bigdata.core.framework.dao.WordCountDao
import org.apache.spark.rdd.RDDclass WordCountService extends TService {private val wordCountDao = new WordCountDao()//数据分析def dataAnalysis() = {val lines = wordCountDao.readFile("datas/word.txt")// hello world =>hello,word, hello,wordval words: RDD[String] = lines.flatMap(_.split(" "))val wordToOne = words.map(word => (word, 1))//3、将数据根据单词进行分组、便于统计//  (hello,hello,hello),(world, world)val wordGroup: RDD[(String, Iterable[(String, Int)])] = wordToOne.groupBy(t => t._1)//4、对分组后的数据进行转换val wordToCount = wordGroup.map {// word 是 单词(list[]) 格式case (word, list) => {list.reduce((t1, t2) => {(t1._1, t1._2 + t2._2)})}}val array: Array[(String, Int)] = wordToCount.collect()array}}

util包

package com.spack.bigdata.core.framework.utilimport org.apache.spark.SparkContext/*** ThreadLocal*/
object EnvUtil {private val scLocal = new ThreadLocal[SparkContext]def put(sc: SparkContext): Unit = {scLocal.set(sc)}def take(): SparkContext = {scLocal.get()}def clear(): Unit = {scLocal.remove()}
}

common包

TApplication

package com.spack.bigdata.core.framework.commonimport com.spack.bigdata.core.framework.controller.WordCountController
import com.spack.bigdata.core.framework.util.EnvUtil
import org.apache.spark.{SparkConf, SparkContext}trait TApplication {def start(master: String = "local[*]", app: String = "Application")(op: => Unit): Unit = {val conf = new SparkConf().setMaster(master).setAppName(app)val sc = new SparkContext(conf)EnvUtil.put(sc)try {op} catch {case ex => println(ex.getMessage)}//TODO 关闭连接sc.stop()EnvUtil.clear()}}

TController

package com.spack.bigdata.core.framework.commontrait TController {def dispatch(): Unit
}

TDao

package com.spack.bigdata.core.framework.commonimport com.spack.bigdata.core.framework.util.EnvUtil
import org.apache.spark.SparkContexttrait TDao {def readFile(path: String) = {EnvUtil.take().textFile(path)}
}
package com.spack.bigdata.core.framework.commontrait TService {def dataAnalysis(): Any
}

大数据之Spark案例实操完整使用(第六章)相关推荐

  1. 大数据培训课程数据清洗案例实操-简单解析版

    数据清洗(ETL) 在运行核心业务MapReduce程序之前,往往要先对数据进行清洗,清理掉不符合用户要求的数据.清理的过程往往只需要运行Mapper程序,不需要运行Reduce程序.大数据培训 数据 ...

  2. 大数据培训课程WordCount案例实操

    WordCount案例实操 1．需求 在给定的文本文件中统计输出每一个单词出现的总次数 (1)输入数据 (2)期望输出数据 atguigu   2 banzhang 1 cls   2 hadoop  ...

  3. 大数据框架介绍与实操

    文章目录 一. 大数据开源框架汇总简介 1.1 hadoop 1.2 hdfs 1.3 yarn 1.4 mapreduce 1.5 spark 1.6 hbase 1.7 zookeeper 1.8 ...

  4. 尚硅谷大数据技术Spark教程-笔记09【SparkStreaming（概念、入门、DStream入门、案例实操、总结）】

    尚硅谷大数据技术-教程-学习路线-笔记汇总表[课程资料下载] 视频地址:尚硅谷大数据Spark教程从入门到精通_哔哩哔哩_bilibili 尚硅谷大数据技术Spark教程-笔记01[SparkCore ...

  5. Spark转换算子大全以及案例实操

    1.RDD 转换算子 RDD转换算子实际上就是换了名称的RDD方法 RDD 根据数据处理方式的不同将算子整体上分为 Value 类型.双 Value 类型和 Key-Value 类型 算子:Opera ...

  6. 航空专场 | 无人机设计仿真流程讲解与案例实操

    一.CFD在无人机上的应用 1.静.动气动系数计算以上介绍的无人机的流动状态一般为中低雷诺数,不可压缩流动.这些计算一般用S-A模型或者KW-SST模型进行计算,能够获得不错的工程精度.静.动气动力系 ...

  7. 尚硅谷大数据技术Spark教程-笔记01【Spark(概述、快速上手、运行环境、运行架构)】

    视频地址:尚硅谷大数据Spark教程从入门到精通_哔哩哔哩_bilibili 尚硅谷大数据技术Spark教程-笔记01[Spark(概述.快速上手.运行环境.运行架构)] 尚硅谷大数据技术Spark教 ...

  8. 大数据之Scala变量和数据类型完整使用 (第二章)

    大数据之Scala变量和数据类型完整使用 一.注释 1)基本语法 2)案例实操 3) 代码规范 二.变量和常量(重点) 0)回顾:Java 变量和常量语法 1)基本语法 2)案例实操 三.标识符的命名 ...

  9. 数据科学与大数据技术的案例_主数据科学案例研究，招聘经理的观点

    数据科学与大数据技术的案例 I've been in that situation where I got a bunch of data science case studies from diff ...

最新文章

  1. 主席树 ---- CF 1422F. Boring Queries(由离线推出在线如何求的 ，求解多次询问的区间LCM)
  2. Linux内核BPF学习1
  3. mysql二进制安装的优缺点_MYSQL的二进制安装
  4. OpenGL Draw TransformFeedback 绘制变换反馈的实例
  5. java 正则表达式语法_Java 正则表达式基础语法
  6. Linux下arp用法
  7. 【转】.net异步性能测试（包括ASP.NET MVC WebAPI异步方法）
  8. 揭秘！业界创新的代码仓库加密技术
  9. unity---------------------关于BuildAssetBundles的使用（打包）
  10. oracle首先创建三个表,oracle一个创建用户、创建表空间、授权、建表的完整过程...
  11. ps cs6导出html,渲染视频使用不了是怎么回事？pscs6ex – 手机爱问
  12. beanstalkd
  13. 8- 性能测试面试题（测试框架总结）史上最全面试题
  14. javascript DOM 操作基础知识小结
  15. 桌面图标去掉小箭头的方法
  16. Vue3 异步组件 suspense
  17. 某大厂外包员工抢了个红包，被要求退回，太侮辱人了！千万别做外包，狗都不如...
  18. “七段数码管绘制”实例详解
  19. mapbox中文地图_使用 Mapbox 地图
  20. spring @Autowired用法

热门文章

  1. 计算机桌面太亮,win7电脑屏幕太亮看起来很刺眼怎么办
  2. 雷军做程序员时写的博客太棒了
  3. 秀秀的照片（photo）
  4. 【解决方案】EasyCVR智能安防监控平台在石油能源行业中的应用
  5. BIM软件下载安装目录
  6. 首都经贸计算机考研怎么样,首都经济贸易大学考研难吗？一般要什么水平才可以进入？...
  7. 零基础学python知乎-python学画画（上）
  8. 嵌入式 Linux 入门 环境篇（三、开发板和 PC 的网络互通）
  9. FPGA作业1：利用74161设计12进制计数器
  10. 基本排序算法01----选择排序(selection sort)