Spark实战案例-需求1-Top10热门品类

已于 2023-12-28 15:33:06 修改
阅读量4.9k 收藏 86
点赞数 5
分类专栏： Spark 文章标签： spark
于 2021-03-09 18:38:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39346903/article/details/114594476
版权

上一篇：Spark教程-1.SparkCore

文章目录

第5章 Spark案例实操

在之前的学习中，我们已经学习了Spark的基础编程方式，接下来，我们看看在实际的工作中如何使用这些API实现具体的需求。这些需求是电商网站的真实需求，所以在实现功能前，咱们必须先将数据准备好。

image-20210309181327882

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

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

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

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

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

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

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

详细字段说明：

编号字段名称字段类型字段含义
1dateString用户点击行为的日期
2user_idLong用户的ID
3session_idStringSession的ID
4page_idLong某个页面的ID
5action_timeString动作的时间点
6search_keywordString用户搜索的关键词
7click_category_idLong某一个商品品类的ID
8click_product_idLong某一个商品的ID
9order_category_idsString一次订单中所有品类的ID集合
10order_product_idsString一次订单中所有商品的ID集合
11pay_category_idsString一次支付中所有品类的ID集合
12pay_product_idsString一次支付中所有商品的ID集合
13city_idLong城市 id

样例类：

//用户访问动作表
case class UserVisitAction(
    date: String,//用户点击行为的日期
    user_id: Long,//用户的ID
    session_id: String,//Session的ID
    page_id: Long,//某个页面的ID
    action_time: String,//动作的时间点
    search_keyword: String,//用户搜索的关键词
    click_category_id: Long,//某一个商品品类的ID
    click_product_id: Long,//某一个商品的ID
    order_category_ids: String,//一次订单中所有品类的ID集合
    order_product_ids: String,//一次订单中所有商品的ID集合
    pay_category_ids: String,//一次支付中所有品类的ID集合
    pay_product_ids: String,//一次支付中所有商品的ID集合
    city_id: Long//城市 id
)

6.1 需求1：Top10热门品类

image-20210309103118937

6.1.1 需求说明

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

鞋 点击数 下单数 支付数

衣服 点击数 下单数 支付数

电脑 点击数 下单数 支付数

例如，综合排名 = 点击数20%+下单数30%+支付数*50%

本项目需求优化为：先按照点击数排名，靠前的就排名高；如果点击数相同，再比较下单数；下单数再相同，就比较支付数。

6.1.2 实现方案一

6.1.2.1 需求分析

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

（品类，点击总数）（品类，下单总数）（品类，支付总数）

6.1.2.2 需求实现
package com.atguigu.bigdata.spark.core.rdd.req

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

object Req1_HotCategoryTop10Analysis {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local").setAppName("RDDCreate")
    val sc = new SparkContext(sparkConf)
    // TODO 1.获取原始数据
    val actionRDD = sc.textFile("datas/user_visit_action.txt")
    // TODO 2.分别统计一个品类的点击数量，下单数量，支付数量
    // 2.1 品类的点击数量的统计
    // 保留点击数据，其他数据不要
    val clickActionRDD = actionRDD.filter(
      action => {
        val datas = action.split("_")
        datas(6) != "-1"
      }
    )
    //（品类ID，1 click）=> (品类ID，sum click)
    val clickRDD = clickActionRDD.map(
      action => {
        val datas = action.split("_")
        (datas(6), 1)
      }
    )
    // (品类ID，sum click)
    val totalClickRDD = clickRDD.reduceByKey(_ + _)

    // 2.2 品类的下单数量的统计
    // 保留下单数据，其他数据不要
    val orderActionRDD = actionRDD.filter(
      action => {
        val datas = action.split("_")
        datas(8) != "null"
      }
    )
    // （品类ID，1 order）=> (品类ID，sum order)
    val orderRDD = orderActionRDD.flatMap(
      action => {
        val datas = action.split("_")
        val categoryids = datas(8)
        val ids = categoryids.split(",")
        ids.map((_, 1))
      }
    )
    // (品类ID，sum order)
    val totalOrderRDD = orderRDD.reduceByKey(_ + _)

    // 2.3 品类的支付数量的统计
    val payActionRDD = actionRDD.filter(
      action => {
        val datas = action.split("_")
        datas(10) != "null"

      }
    )
    // （品类ID，1 pay）=> (品类ID，sum pay)
    val payRDD = payActionRDD.flatMap(
      action => {
        val datas = action.split("_")
        val categoryids = datas(10)
        val ids = categoryids.split(",")
        ids.map((_, 1))
      }
    )
    // (品类ID，sum pay)
    val totalPayRDD = payRDD.reduceByKey(_ + _)

    // TODO 3. 将统计结果进行排行（点击，下单，支付）
    // Scala可以将无关的数据封装为一个整体来使用，可以使用元组
    // 元组在scala中的排序方式，首先按照第一个元素排序，相同者，按照第二个元素排序，依此类推

    // (品类ID,(点击数量，下单数量，支付数量))
    val clickLeftJoinOrderRDD: RDD[(String, (Int, Option[Int]))] = totalClickRDD.leftOuterJoin(totalOrderRDD)
    val clickOrderPayRDD: RDD[(String, ((Int, Option[Int]), Option[Int]))] = clickLeftJoinOrderRDD.leftOuterJoin(totalPayRDD)

    // ((Int, Option[Int]), Option[Int]))
    // ((点击，下单)，支付)
    val wantRDD = clickOrderPayRDD.map {
      case (cid, ((click, optOrder), optPay)) => {
        val order = optOrder.getOrElse(0)
        val pay = optPay.getOrElse(0)
        (cid, ((click, order), pay))
      }
    }

    // TODO 4.  取前10名
    //根据(click, order), pay)排序，false是降序,take取前10
    val result: Array[(String, ((Int, Int), Int))] = wantRDD.sortBy(_._2, false).take(10)
    result.foreach(println)
    sc.stop()

  }
}

6.1.3 实现方案二

6.1.3.1 需求分析

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

（品类，（点击总数，下单总数，支付总数））

6.1.3.2 需求实现
package com.atguigu.bigdata.spark.core.rdd.req

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


object Req1_HotCategoryTop10Analysis2 {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local").setAppName("RDDCreate")
    val sc = new SparkContext(sparkConf)

    // TODO 1. 获取原始数据
    val actionRDD = sc.textFile("datas/user_visit_action.txt")
    actionRDD.cache()

    // TODO 2. 分别统计一个品类的点击数量，下单数量，支付数量

    // Q : actionRDD，读取文件中，重复使用?
    // A : 即使对象重复使用，但是数据无法重复使用，因为RDD不保存数据，从头执行数据操作
    //     可以采用持久化操作
    // Q : reduceByKey算子被调用的次数过多，性能下降。？
    // A : 极限情况下，使用一个reduceByKey实现功能
    // Q : 连接3个数据源时，会导致性能下降？
    // A : 改变数据结构，提升计算性能

    //点击
    val clickActionRDD = actionRDD.filter(
      action => {
        val datas: Array[String] = action.split("_")
        datas(6) != "-1"
      }
    )

    val clickRDD = clickActionRDD.map(
      action => {
        val datas: Array[String] = action.split("_")
        ( datas(6), 1 )
      }
    )
    // （品类ID，1）=> ( 品类，（1，0，0） )
    // reduceByKey丢弃？？？
    val totalClickRDD = clickRDD.reduceByKey(_+_)

    // 订单
    val orderActionRDD = actionRDD.filter(
      action => {
        val datas: Array[String] = action.split("_")
        datas(8) != "null"
      }
    )

    val orderRDD = orderActionRDD.flatMap(
      action => {
        val datas: Array[String] = action.split("_")
        val categoryids = datas(8)
        val ids = categoryids.split(",")
        ids.map( (_, 1) )
      }
    )

    // （品类ID，1） => （品类，（0，1，0））
    // reduceByKey是否丢弃？？？
    val totalOrderRDD: RDD[(String, Int)] = orderRDD.reduceByKey(_+_)

    //支付
    val payActionRDD = actionRDD.filter(
      action => {
        val datas: Array[String] = action.split("_")
        datas(10) != "null"
      }
    )
    val payRDD = payActionRDD.flatMap(
      action => {
        val datas: Array[String] = action.split("_")
        val categoryids = datas(10)
        val ids = categoryids.split(",")
        ids.map( (_, 1) )
      }
    )

    // （品类ID， 1）=> (品类，（0，0，1）)
    // reduceByKey丢弃？？？
    val totalPayRDD: RDD[(String, Int)] = payRDD.reduceByKey(_+_)

    // TODO 3. 将统计结果进行排行(降序)（ 点击， 下单， 支付 ）
    // ( 品类ID， (点击数量, 0, 0) )
    val newClickRDD = totalClickRDD.map{
      case ( id, clickCnt ) => {
        ( id, (clickCnt, 0, 0) )
      }
    }
    // ( 品类ID， (0, 下单数量, 0) )
    val newOrderRDD = totalOrderRDD.map {
      case ( id, orderCnt ) => {
        ( id, (0, orderCnt, 0) )
      }
    }
    // ( 品类ID， (0, 0, 支付数量) )
    val newPayRDD = totalPayRDD.map {
      case ( id, payCnt ) => {
        ( id, (0, 0, payCnt) )
      }
    }
    // (1, (1,0,0))
    // (1, (0,2,0))
    // (1, (0,0,3))
    // => (1, (1,2,3))
    // union
    val rdd: RDD[(String, (Int, Int, Int))] = newClickRDD.union(newOrderRDD).union(newPayRDD)
    // ( 品类ID, ( 点击数量，下单数量，支付数量 ) )
    val wantRDD = rdd.reduceByKey{
      case ( (c1, o1, p1), (c2, o2, p2) ) => {
        ( c1 + c2, o1 + o2, p1 + p2 )
      }
    }
    // TODO 4. 取前10名
    val result: Array[(String, (Int, Int, Int))] = wantRDD.sortBy(_._2, false).take(10)

    result.foreach(println)
    sc.stop

  }
}

方案二优化：

package com.atguigu.bigdata.spark.core.rdd.req

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

object Req1_HotCategoryTop10Analysis3 {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local").setAppName("RDDCreate")
    val sc = new SparkContext(sparkConf)

    // TODO 1. 获取原始数据
    val actionRDD = sc.textFile("datas/user_visit_action.txt")
    // TODO 2. 将原始数据进行结构的转换
    //点击 => ( 品类， （1，0，0） )
    //下单 => ( 品类1，（0，1，0）),  ( 品类2，（0，1，0）)
    //支付 => (品类1，（0，0，1）), (品类2，（0，0，1）)

    // map : 数据不会增多，只是 A => B
    // flatMap : 数据可能会增多
    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")) {
          // 下单
          List((datas(8), (0, 1, 0)))
        } else if ((datas(10) != "null")) {
          // 支付
          List((datas(10), (0, 0, 1)))
        } else {
          Nil
        }
      }
    )
    val resultRDD: RDD[(String, (Int, Int, Int))] = flatRDD.reduceByKey {
      case ((c1, o1, p1), (c2, o2, p2)) => {
        (c1 + c2, o1 + o2, p1 + p2)
      }
    }
    resultRDD.sortBy(_._2, false).take(10).foreach(println)
    
    sc.stop()

  }
}

6.1.4 实现方案三

6.1.4.1 需求分析

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

6.1.4.2 需求实现
package com.atguigu.bigdata.spark.core.rdd.req


import org.apache.spark.util.AccumulatorV2
import org.apache.spark.{SparkConf, SparkContext}

import scala.collection.mutable

object Req1_HotCategoryTop10Analysis4 {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local").setAppName("RDDCreate")
    val sc = new SparkContext(sparkConf)

    // TODO 1. 获取原始数据
    val actionRDD = sc.textFile("datas/user_visit_action.txt")

    // 不使用shuffle操作完成数据统计
    // 创建累加器
    val acc = new HotCategoryAccumulator()
    sc.register(acc, "hotCategory")

    actionRDD.foreach(
      action => {
        val datas = action.split("_")
        if (datas(6) != "-1") {
          //点击
          acc.add(datas(6), "click") //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 hotCategoryMap: mutable.Map[String, HotCategory] = acc.value //拿到map的结果

    // TODO 将累加的结果进行排序（降序）和取前10名
    // Map[String, HotCategory] 只需要 HotCategory
    // map没有排序功能，需要toList
    // sortWith，这里不是tuple，是一个一个的对象，对象需要用自定义的规则，sortWith有左右
    hotCategoryMap.map(_._2).toList.sortWith(
      (left, right) => {
        if (left.clickCount > right.clickCount) {
          true
        } else if (left.clickCount == right.clickCount) {
          if (left.orderCount > right.orderCount) {
            true
          } else if (left.orderCount == right.orderCount) {
            left.payCount > right.payCount
          } else {
            false
          }
        } else {
          false
        }
      }
    ).take(10).foreach(println) //取前10


    sc.stop()

  }

  // 输入IN: （品类，行为类型）
  // 输出OUT: Map[品类，HotCategory] ， HotCategory中封装（点击数量，下单数量，支付数量）

  class HotCategoryAccumulator extends AccumulatorV2[(String, String), mutable.Map[String, HotCategory]] {
    private val hotCategoryMap = mutable.Map[String, HotCategory]()


    override def isZero: Boolean = {
      hotCategoryMap.isEmpty //初始化,就是没有值
    }

    override def copy(): AccumulatorV2[(String, String), mutable.Map[String, HotCategory]] = {
      new HotCategoryAccumulator()
    }

    override def reset(): Unit = {
      hotCategoryMap.clear() //清除
    }


    override def add(v: (String, String)): Unit = {
      val id = v._1 //品类id
      val actionType = v._2 //行为类型

      // 判断map里面有没有这个id，有就拿过来，没有就用新的
      val hotCategory = hotCategoryMap.getOrElse(id, HotCategory(id, 0, 0, 0))

      // 行为类型之中有三种，用match匹配
      actionType match {
        case "click" => hotCategory.clickCount += 1 // 是哪种类型就加1
        case "order" => hotCategory.orderCount += 1
        case "pay" => hotCategory.payCount += 1
      }
      // 增加:从之前的map中取出旧的值，根据条件进行更新，更新后再放回去
      // 把这个map更新
      hotCategoryMap.update(id, hotCategory)
    }

    // merge 就是两个map的合并,合并当前和其他的
    override def merge(other: AccumulatorV2[(String, String), mutable.Map[String, HotCategory]]): Unit = {
      other.value.foreach { // 这个value是map：Map[String, HotCategory]
        case (id, otherHC) => {
          val thisHC = hotCategoryMap.getOrElse(id, HotCategory(id, 0, 0, 0))

          thisHC.clickCount += otherHC.clickCount
          thisHC.orderCount += otherHC.orderCount
          thisHC.payCount += otherHC.payCount

          // 更新一下
          hotCategoryMap.update(id, thisHC)

        }
      }
    }

    // 返回
    override def value: mutable.Map[String, HotCategory] = hotCategoryMap
  }

  // 样例类
  case class HotCategory(
                          var categoryId: String,
                          var clickCount: Long,
                          var orderCount: Long,
                          var payCount: Long,
                        )

}

测试数据百度网盘链接: 链接：https://pan.baidu.com/s/1t-4PeV8hiGpHYs_17LCFUw?pwd=aza1 提取码：aza1

上一篇：Spark教程-1.SparkCore

工藤-新二
关注
  • 5
    点赞
  • 踩
  • 86
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
Spark数据项目实例一
qq_40333693的博客
11-19 1万+
源数据：https://pan.baidu.com/s/1rzEwBfR1m_lpZHekuEFnCg 提取码：tgpf 使用Spark完成下列日志分析项目需求： 日志数据清洗 用户留存分析 活跃用户分析 活跃用户地域信息分析 用户浏览深度分析 数据清洗 1）读入日志文件并转化为RDD[Row]类型 按照Tab其人格数据 过滤掉字段数量少于8个的 val line1 = linesRDD.map(x => x.split("\t")) val rdd = line1.filter(x => x.
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实验案例
qq_36365123的博客
06-08 3150
一、实验目的 （1）熟悉Spark的RDD基本操作及键值对操作； （2）熟悉使用RDD编程解决实际具体问题的方法。 二、实验平台 操作系统：Ubuntu16.04 Spark版本：2.4.0 Python版本：3.4.3 三、实验内容和要求 1．pyspark交互式编程 本作业提供分析数据data.txt，该数据集包含了某大学计算机系的成绩，数据格式如下所示： Tom,DataBase,80 Tom,Algorithm,50 Tom,DataStructure,60 Jim,DataBase,90 Jim,
Spark【RDD编程（四）综合案例】
梦想是动物管理员
09-07 1010
Spark RDD编程综合案例
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：从入门到实战（附视频教程&项目源码）
bella_IT的博客
08-05 5832
本文是由菜鸟窝出品的12天大数据特训营课程摘录出来的，关于大数据spark的入门到实战视频可以戳此查看第三章：https://www.cniao5.com/course/10244 勾搭助教Bella的weixin（BT474849）还可以免费领取大数据独家内部视频资源，项目源码等。 一、Spark简介 1、大数据spark简介： Spark是大数据相关的最活跃的开源项目，是继 MapReduce...
apache-doris-spark-connector-2.3_2.11-1.0.1
05-05
Spark Doris Connector（apache-doris-spark-connector-2.3_2.11-1.0.1-incubating-src.tar.gz） Spark Doris Connector Version：1.0.1 Spark Version：2.x Scala Version：2.11 Apache Doris是一个现代MPP分析...
spark-2.0.0-bin-hadoop2.6.tgz
11-13
本资源是spark-2.0.0-bin-hadoop2.6.tgz百度网盘资源下载,本资源是spark-2.0.0-bin-hadoop2.6.tgz百度网盘资源下载
apache-doris-spark-connector-3.1_2.12-1.0.1
05-05
Spark Doris Connector（apache-doris-spark-connector-3.1_2.12-1.0.1-incubating-src.tar.gz） Spark Doris Connector Version：1.0.1 Spark Version：3.x Scala Version：2.12 Apache Doris是一个现代MPP分析...
spark-2.4.7-bin-hadoop2.6.tgz
03-17
在部署和使用Spark时，需要根据实际需求配置`spark-defaults.conf`，设置如master节点地址、内存分配、日志级别等参数。此外，可以通过`spark-submit`脚本提交应用程序到Spark集群执行，或直接在Spark Shell中交互式...
Spark最全操作完整示例代码
08-03
最全Spark操作完整示例代码-------是基于java的。 包含所有的spark常用算子操作和ml以及mlib、sparkstreaming、sparkSQL操作的示例DEMO。 内附有详细说明,由于内容过大删除了两个jar包,需要自己去下载,spark的安装包下的有这两个包，导入项目即可。懒得改maven项目了。 适合有一定基础和已经工作的人员下载学习。 个人Github: https://github.com/huangyueranbbc
Spark简单测试案例
01-09
Spark自带案例、代码案例测试! 环境： Hadoop1.2集群和Spark1.0集群 3个节点的Ubuntu12.1系统机器
spark-3.5.1-bin-hadoop3.tgz
最新发布
04-22
Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎。Spark是UC Berkeley AMP lab (加州大学伯克利分校的AMP实验室)所开源的类Hadoop MapReduce的通用并行框架，Spark，拥有Hadoop MapReduce所具有的优点...
spark读文件忽略第一行_Spark 核心概念与操作
weixin_40001309的博客
11-28 1196
spark简介Apache Spark是新兴的一种快速通用的大规模数据处理引擎。它的优势有三个方面：通用计算引擎 能够运行MapReduce、数据挖掘、图运算、流式计算、SQL等多种框架；基于内存 数据可缓存在内存中，特别适用于需要迭代多次运算的场景；与Hadoop集成 能够直接读写HDFS中的数据，并能运行在YARN之上。Spark是用Scala语言编写的，所提供的API也很好地利用了...
Spark 案例（依据电商网站的真实需求）
Faith_xzc
08-21 1633
目录数据说明需求1：Top10 热门品类需求说明实现方案一需求分析需求实现实现方案二需求分析需求实现实现方案三需求分析需求实现需求 2：Top10 热门品类中每个品类的 Top10 活跃Session 统计需求说明需求分析需求实现 数据说明 在前面的博客中已经介绍了了 Spark 的基础编程方式，接下来，再看下在实际的工作中如何使用这些 API 实现具体的需求。这些需求是电商网站的真实需求，所以在实现功能前，先将数据准备好。 数据文档链接 提取码：xzc6 上面的数据图是从数据文件中截取的一部分内容，表示
Spark实战案例---TopN主播统计
brotherand的博客
07-09 1211
Spark完成TopN主播数据统计
spark实战之：分析维基百科网站统计数据(java版)
2401_83916241的博客
04-04 863
由于篇幅有限，这里就不一一罗列了，20道常见面试题（含答案）+21条MySQL性能调优经验小编已整理成Word文档或PDF文档还有更多面试复习笔记分享如下《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门即可获取！3291th 1012375vi 1007987he 822433cs 750085hu 687040自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
Spark大数据技术与应用期末总结大题
qq_56437391的博客
06-15 2622
PySpark启动以Local,yarn,standalone,mesos2、控制日志级别，有效的日志级别包括：ALL, DEBUG, ERROR, FATAL, INFO, OFF, TRACE, WARN控制日志输出内容的方式有两种log4j.rootCategory=INFO, console和from pyspark import SparkContext sc =SparkContext(“local”,”First App”) sc.setLogLevel(“WARN”)3、RDD是什么弹性分.
第二章：Spark SQL综合实战
11-07
1.Spark SQL JDBC服务介绍2.Spark SQL MetaStore Server构建3.深度了解Spark SQL运行计划与调优4.Spark SQL DataSets API实践完成数据分析5.JSON数据源复杂综合案例实战
视频教程-spark实战教程-spark
03-16
Spark实战教程是一种视频教程，旨在帮助学习者了解和掌握Spark的基本概念和实践技能。该教程涵盖了Spark的核心概念、编程模型、数据处理、机器学习等方面，通过实际案例演示和练习，帮助学习者深入理解Spark的应用场景和实现方法。该教程适合有一定编程基础和数据处理经验的学习者，可以帮助他们快速掌握Spark的使用技巧和应用方法。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

工藤-新二

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值