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

已于 2023-12-28 15:33:06 修改
阅读量5.7k 收藏 98
点赞数 8
分类专栏： 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

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项目实战:大数据实时流处理日志(非常详细)
热门推荐
萧邦主的城邦
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案例实践——广告点击实时分析
最新发布
slb190623的博客
11-02 783
Spark案例实践——广告点击实时分析
Spark实战教程
03-30
本课程内容包括Spark简介、安装、快速入门、RDD编程、独立模式、集群模式、Spark SQL入门、Spark SQL数据源、Spark Streaming，MLlib机器学习、实例（淘宝双11大数据分析）等等。
Spark编程经典综合案例
MusicDancing的博客
09-04 3244
1. 求TOP值 2. 求最大值最小值 3. 文件排序 4. 二次排序 5. 连接操作 1. WordCount程序解析
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案例实际操作
m0_47489229的博客
08-21 2145
Spark的案例
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.4.7-bin-hadoop2.6.tgz
03-17
在部署和使用Spark时，需要根据实际需求配置`spark-defaults.conf`，设置如master节点地址、内存分配、日志级别等参数。此外，可以通过`spark-submit`脚本提交应用程序到Spark集群执行，或直接在Spark Shell中交互式...
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-3.5.1-bin-hadoop3.tgz
04-22
Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎。Spark是UC Berkeley AMP lab (加州大学伯克利分校的AMP实验室)所开源的类Hadoop MapReduce的通用并行框架，Spark，拥有Hadoop MapReduce所具有的优点...
大数据之Spark案例实操完整使用(第六章)
小坏说后端
06-27 2632
上面的数据图是从数据文件中截取的一部分内容，表示为电商网站的用户行为数据，主要包含用户的 4 种行为：搜索，点击，下单，支付。数据规则如下：➢ 数据文件中每行数据采用下划线分隔数据➢ 每一行数据表示用户的一次行为，这个行为只能是 4 种行为的一种➢ 如果搜索关键字为 null,表示数据不是搜索数据➢ 如果点击的品类 ID 和产品 ID 为-1，表示数据不是点击数据➢ 针对于下单行为，一次可以下单多个商品，所以品类 ID 和产品 ID 可以是多个，id 之间采用逗号分隔，如果本次不是下单行为，则数据采用 nu
基于Spark MLib的鸢尾花数据聚类项目实战案例
Sartin的博客
08-17 4789
目录背景KMeans原理实训操作一、准备数据二、对数据进行聚类 背景 聚类（Cluster analysis）有时也被翻译为簇类，其核心任务是：将一组目标object划分为若干个簇，每个簇之间的object尽可能相似，簇与簇之间的object尽可能相异。聚类算法是机器学习（或者说是数据挖掘更合适）中重要的一部分，除了最为简单的K-Means聚类算法外，比较常见的还有层次法（CURE、CHAMELEON等）、网格算法（STING、WaveCluster等），等等。 较权威的聚类问题定义：所谓聚类问题，就是给定
Spark案例实战教程
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
02-17 7727
Spark案例实战 实战代码参考：GitHub - GoAlers/Bigdata_project: 电商大数据项目-推荐系统(java和scala语言) ​
Spark的7个案例
rentian1的博客
05-07 1568
/** * 1.处理average.txt，计算出第二列数据的均值 * 1 16 * 2 74 */ package com.dasenlin.spark import org.apache.spark.SparkConf import org.apache.spark.SparkContext object Average { def main(args: Arra...
使用 Scala 语言开发 Spark 应用程序
scalad
03-06 3494
本文旨在通过具有实际意义的案例向读者介绍如何使用 Scala 语言开发 Spark 应用程序并在 Spark 集群上运行。本文涉及的所有源数据都将从 HDFS（Hadoop Distributed File System）读取，部分案例的输出结果也会写入到 HDFS, 所以通过阅读本文，读者也会学习到 Spark 和 HDFS 交互的一些知识 引言 在当前这个信息时代里，大数据所蕴含的
spark项目实战-电商分析平台
lukabruce的博客
03-25 1万+
第1章 项目概述 电商分析平台是对用户访问电商平台的行为进行分析。 1.1 项目简介   本项目主要讲解一个大型电商网站后台的企业级大数据统计分析平台，该平台以 Spark 为主，对电商网站的流量进行离线和实时的分析。   该大数据分析平台对电商网站的各类用户行为（访问行为、购物行为、广告点击行为等）进行复杂的分析。用统计分析出来的数据，辅助公司中的 PM（产品经理）、数据分析师以及管理人员分析现有产品的状况，并根据用户行为分析结果持续改进产品的设计，以及调整公司的战略和业务。最终达到用大数...
Spark经典案例分享
pblh123的专栏
11-29 1025
Spark经典案例，链接操作案例、二次排序案例
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

工藤-新二

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

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

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

打赏作者

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

抵扣说明：

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

余额充值