Spark 案例实操（电商）

最新推荐文章于 2023-10-20 14:06:27 发布
最新推荐文章于 2023-10-20 14:06:27 发布
阅读量572 收藏 4
点赞数 2
文章标签： spark scala 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/peimina/article/details/130105282
版权

Spark 案例实操

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

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

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

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

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

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

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

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

详细字段说明：
在这里插入图片描述
在这里插入图片描述

样例类：

//用户访问动作表
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

需求 1：Top10 热门品类

需求说明

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

鞋 点击数 下单数 支付数

衣服 点击数 下单数 支付数

电脑 点击数 下单数 支付数

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

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

实现方案一

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

（品类，点击总数）（品类，下单总数）（品类，支付总数）=> (品类，（点击总数，下单总数，支付总数)）

object Spark01_Req1_HotCategoryTop10Analysis {

  def main(args: Array[String]): Unit = {
    //TODO :Top10热门品类
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("HotCategoryTop10Analysis")
    val sc = new SparkContext(sparkConf)

    //1.读取原始日志数量
    val actionRDD: RDD[String] = sc.textFile("datas/user_visit_action.txt")


    //2.统计品类的点击数量：（品类ID，点击数量）
    //过滤掉不是点击行为的数据
    val clickActionRDD = actionRDD.filter(
      action => {
        val datas: Array[String] = action.split("_")
        datas(6) != "-1"  //品类ID不等于-1则为点击数据
      }
    )

    val clickCountRDD: RDD[(String, Int)] = clickActionRDD.map(
      action => {
        val datas: Array[String] = action.split("_")
        (datas(6), 1)         //映射成(品类ID，1) 就类似于wordCount
      }
    ).reduceByKey(_ + _)

    //3.统计品类的下单数量：（品类ID，下单数量）
    val orderActionRDD = actionRDD.filter(
      action => {
        val datas: Array[String] = action.split("_")
        datas(8) != "null"
      }
    )

    //orderid => 1,2,3,
    //[(1,1),(2,1),(3,1)
    val orderCoundRDD: RDD[(String, Int)] = orderActionRDD.flatMap(
      action => {
        val datas = action.split("_")
        val cid = datas(8)   //cid为一次订单中所有品类ID的集合
        val cids = cid.split(",")     //得到一次订单的所有的品类ID
        cids.map(id => (id, 1))          //再把所有品类ID映射成（品类ID，1）
      }
    ).reduceByKey(_ + _)   //在做聚合

    //4.统计品类的支付数量：（品类ID，支付数量）

    val payActionRDD = actionRDD.filter(
      action => {
        val datas: Array[String] = action.split("_")
        datas(10) != "null"
      }
    )

    //orderid => 1,2,3,
    //[(1,1),(2,1),(3,1)
    val payCoundRDD: RDD[(String, Int)] = orderActionRDD.flatMap(
      action => {
        val datas = action.split("_")
        val cid = datas(10)
        val cids = cid.split(",")
        cids.map(id => (id, 1))
      }
    ).reduceByKey(_+_)

    //5.将品类进行排序，并且取前10名
    //  点击数量排序，下单数量排序，支付数量排序
    //  元祖排序：先比较第一个，再比较第二个，再比较第三个，依此类推
    // (品类ID，（点击数量，下单数量，支付数量））
    //cogroup= connect + group
    val cogroupRDD: RDD[(String, (Iterable[Int], Iterable[Int], Iterable[Int]))] = clickCountRDD.cogroup(orderCoundRDD,payCoundRDD)
    val analysisRDD: RDD[(String, (Int, Int, Int))] = cogroupRDD.mapValues {
      case (clickIter, orderIter, payIter) => {
        var clickCnt = 0
        val iter1: Iterator[Int] = clickIter.iterator
        if (iter1.hasNext) {
          clickCnt = iter1.next()
        }
        var orderCnt = 0
        val iter2 = orderIter.iterator
        if (iter2.hasNext) {
          orderCnt = iter2.next()
        }
        var payCnt = 0
        val iter3 = payIter.iterator
        if (iter3.hasNext) {
          payCnt = iter3.next()
        }
        (clickCnt, orderCnt, payCnt)
      }
    }

    val resultRDD: Array[(String, (Int, Int, Int))] = analysisRDD.sortBy(_._2, false).take(10)
    //6.将结果采集到控制台打印出来
    resultRDD.foreach(println)


    sc.stop()
  }
}

实现方案二

（品类ID，点击数量）=>（品类ID，（点击数量，0,0））
（品类ID，下单数量）=>（品类ID，（0，下单，0））
（品类ID，支付数量）=>（品类ID，（0,0，支付数量））
（品类ID，（点击数量，下单数量，支付数量）)

bject Spark02_Req1_HotCategoryTop10Analysis1 {

  def main(args: Array[String]): Unit = {
    //TODO :Top10热门品类
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("HotCategoryTop10Analysis")
    val sc = new SparkContext(sparkConf)

    //1.读取原始日志数量
    val actionRDD: RDD[String] = sc.textFile("datas/user_visit_action.txt")
    actionRDD.cache()
    //Q:actionRDD重复使用
    //Q:cogroup性能可能较低

    //2.统计品类的点击数量：（品类ID，点击数量）
    val clickActionRDD = actionRDD.filter(
      action => {
        val datas: Array[String] = action.split("_")
        datas(6) != "-1"
      }
    )

    val clickCountRDD: RDD[(String, Int)] = clickActionRDD.map(
      action => {
        val datas: Array[String] = action.split("_")
        (datas(6), 1)
      }
    ).reduceByKey(_ + _)

    //3.统计品类的下单数量：（品类ID，下单数量）
    val orderActionRDD = actionRDD.filter(
      action => {
        val datas: Array[String] = action.split("_")
        datas(8) != "null"
      }
    )

    //orderid => 1,2,3,
    //[(1,1),(2,1),(3,1)
    val orderCoundRDD: RDD[(String, Int)] = orderActionRDD.flatMap(
      action => {
        val datas = action.split("_")
        val cid = datas(8)
        val cids = cid.split(",")
        cids.map(id => (id, 1))
      }
    ).reduceByKey(_ + _)

    //4.统计品类的支付数量：（品类ID，支付数量）

    val payActionRDD = actionRDD.filter(
      action => {
        val datas: Array[String] = action.split("_")
        datas(10) != "null"
      }
    )

    //orderid => 1,2,3,
    //[(1,1),(2,1),(3,1)
    val payCoundRDD: RDD[(String, Int)] = payActionRDD.flatMap(
      action => {
        val datas = action.split("_")
        val cid = datas(10)
        val cids = cid.split(",")
        cids.map(id => (id, 1))
      }
    ).reduceByKey(_+_)

    //（品类ID，点击数量）=>（品类ID，（点击数量，0,0））
    //（品类ID，下单数量）=>（品类ID，（0，下单，0））
    //（品类ID，支付数量）=>（品类ID，（0,0，支付数量））
    //（品类ID，（点击数量，下单数量，支付数量）
    //5.将品类进行排序，并且取前10名
    //  点击数量排序，下单数量排序，支付数量排序
    //  元祖排序：先比较第一个，再比较第二个，再比较第三个，依此类推
    // (品类ID，（点击数量，下单数量，支付数量））
    val rdd1 = clickCountRDD.map{
      case (cid,cnt) => {
        (cid,(cnt,0,0))
      }
    }

    val rdd2 = orderCoundRDD.map{
      case (cid,cnt) => {
        (cid,(0,cnt,0))
      }
    }

    val rdd3 = payCoundRDD.map{
      case (cid,cnt) => {
        (cid,(0,0,cnt))
      }
    }

    //将三个数据源合并在一起，统一进行聚合计算
    val soruceRDD: RDD[(String, (Int, Int, Int))] = rdd1.union(rdd2).union(rdd3)

    val analysisRDD = soruceRDD.reduceByKey(
      (t1,t2) => {
        (t1._1+t2._1,t1._2+t2._2,t1._3+t2._3)
      }
    )

    val resultRDD: Array[(String, (Int, Int, Int))] = analysisRDD.sortBy(_._2, false).take(10)
    //6.将结果采集到控制台打印出来
    resultRDD.foreach(println)


    sc.stop()
  }
}

实现方案三

（品类ID，点击数量）=>（品类ID,（1,0,0））
（品类ID，下单数量）=>（品类ID,（0,1,0））
（品类ID，支付数量）=>（品类ID,（0,0,1））
（品类ID，（点击数量，下单数量，支付数量）

object Spark03_Req1_HotCategoryTop10Analysis2 {

  def main(args: Array[String]): Unit = {
    //TODO :Top10热门品类
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("HotCategoryTop10Analysis")
    val sc = new SparkContext(sparkConf)

    //1.读取原始日志数量
    val actionRDD: RDD[String] = sc.textFile("datas/user_visit_action.txt")
    //Q:存在大量的shuffle操作（reduceByKey）
    //reduceByKey聚合算子，spark会提供优化，缓存


    //2.转换数据结构
    //（品类ID，点击数量）=>（品类ID,（1,0,0））
    //（品类ID，下单数量）=>（品类ID,（0,1,0））
    //（品类ID，支付数量）=>（品类ID,（0,0,1））
    //（品类ID，（点击数量，下单数量，支付数量）
    val flatRDD: RDD[(String, (Int, Int, Int))] = actionRDD.flatMap(
      action => {
        val datas: Array[String] = action.split("_")
        if (datas(6) != "-1") {
          List((datas(6), (1, 0, 0)))
        } else if (datas(8) != "null") {
          val ids: Array[String] = datas(8).split(",")
          ids.map(id => (id, (0, 1, 0)))
        } else if (datas(10) != "null") {
          val ids: Array[String] = datas(10).split(",")
          ids.map(id => (id, (0, 0, 1)))
        } else {
          Nil
        }
      }
    )

    //3.将相同的品类ID的数据进行分组聚合
    val analysisRDD: RDD[(String, (Int, Int, Int))] = flatRDD.reduceByKey(
      (t1, t2) => {
        (t1._1 + t2._1, t1._2 + t2._2, t1._3 + t2._3)
      }
    )

    //4.将统计结果根据数量进行降序排列，取前10名
    val resultRDD: Array[(String, (Int, Int, Int))] = analysisRDD.sortBy(_._2, false).take(10)

    //5.将结果采集到控制台打印出来
    resultRDD.foreach(println)

    sc.stop()
  }
}

实现方案四

自定义累加器

object Spark04_Req1_HotCategoryTop10Analysis3 {

  def main(args: Array[String]): Unit = {
    //TODO :Top10热门品类
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("HotCategoryTop10Analysis")
    val sc = new SparkContext(sparkConf)

    //用累加器的方式 没有shuffle




    //1.读取原始日志数量
    val actionRDD: RDD[String] = sc.textFile("datas/user_visit_action.txt")

    val acc = new HotCategoryAccumulator
    sc.register(acc,"hotCategory")

    //2.转换数据结构
    actionRDD.foreach(
      action => {
        val datas: Array[String] = action.split("_")
        if (datas(6) != "-1") {
          acc.add((datas(6),"click"))
        } else if (datas(8) != "null") {
          val ids: Array[String] = datas(8).split(",")
          ids.foreach(
            id => {
              acc.add((id,"order"))
            }
          )
        } else if (datas(10) != "null") {
          val ids: Array[String] = datas(10).split(",")
          ids.foreach(
            id => {
              acc.add((id,"pay"))
            }
          )
        }
      }
    )
    val accValue: mutable.Map[String, HotCategory] = acc.value

    val categories: mutable.Iterable[HotCategory] = accValue.map(_._2)

    val sort: List[HotCategory] = 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
        }
      }
    )

    //5.将结果采集到控制台打印出来
    sort.take(10).foreach(println)

    sc.stop()
  }

  case class HotCategory(cid:String,var clickCnt:Int,var orderCnt:Int,var payCnt:Int)
  /**
   * 自定义累加器
   * 1.集成AccumulatorV2 ，定义泛型
   * IN：（品类ID，行为类型）
   * OUT：mutable.Map[String,HotCatrgory]
   * 2.重写方法6个
   */
  class HotCategoryAccumulator extends AccumulatorV2[(String,String),mutable.Map[String,HotCategory]]{

    private val hcMap = mutable.Map[String,HotCategory]()

    //ctrl+i 重写方法
    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._1
      val actionType = v._2
      val 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.hcMap
      val map2 = other.value

      map2.foreach{
        case (cid,hc) => {
          val category: HotCategory = map1.getOrElse(cid, HotCategory(cid, 0, 0, 0))
          category.clickCnt += hc.clickCnt
          category.orderCnt += hc.orderCnt
          category.payCnt += hc.payCnt
          map1.update(cid,category)
        }
      }
    }

    override def value: mutable.Map[String, HotCategory] = hcMap
  }
}

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

需求说明

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

object Spark05_Req2_HotCategoryTop10SessionAnalysis {

  def main(args: Array[String]): Unit = {
    //TODO :Top10热门品类
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("HotCategoryTop10Analysis")
    val sc = new SparkContext(sparkConf)

    //1.读取原始日志数量
    val actionRDD: RDD[String] = sc.textFile("datas/user_visit_action.txt")
    actionRDD.cache()
    val top10Ids: Array[String] = top10Category(actionRDD)

    //1.过滤原始数据，保留点击和前10品类ID
    val filterActionRDD = actionRDD.filter(
      action => {
        val datas: Array[String] = action.split("_")
        if (datas(6) != "-1"){
          top10Ids.contains(datas(6))
        }else{
          false
        }
      }
    )

    //2.根据品类ID和sessionid进行点击量的统计
    val reduceRDD: RDD[((String, String), Int)] = filterActionRDD.map(
      action => {
        val datas: Array[String] = 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))
      }
    }


    //4.相同的品类进行分组
    val groupRDD: RDD[(String, Iterable[(String, Int)])] = mapRDD.groupByKey()

    //5.将分组后的数据进行点击量的排序，取前10
    val resultRDD: RDD[(String, List[(String, Int)])] = groupRDD.mapValues(
      iter => {
        iter.toList.sortBy(_._2)(Ordering.Int.reverse).take(10)
      }
    )

    resultRDD.collect().foreach(println)


    sc.stop()
  }
  def top10Category(actionRDD:RDD[String]) ={

    val flatRDD: RDD[(String, (Int, Int, Int))] = actionRDD.flatMap(
      action => {
        val datas: Array[String] = action.split("_")
        if (datas(6) != "-1") {
          List((datas(6), (1, 0, 0)))
        } else if (datas(8) != "null") {
          val ids: Array[String] = datas(8).split(",")
          ids.map(id => (id, (0, 1, 0)))
        } else if (datas(10) != "null") {
          val ids: Array[String] = datas(10).split(",")
          ids.map(id => (id, (0, 0, 1)))
        } else {
          Nil
        }
      }
    )

    //3.将相同的品类ID的数据进行分组聚合
    val analysisRDD: RDD[(String, (Int, Int, Int))] = flatRDD.reduceByKey(
      (t1, t2) => {
        (t1._1 + t2._1, t1._2 + t2._2, t1._3 + t2._3)
      }
    )

    //4.将统计结果根据数量进行降序排列，取前10名
    analysisRDD.sortBy(_._2, false).take(10).map(_._1)

  }
}

需求3：页面单跳转换率统计

需求说明

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）统计页面单跳转化率意义

产品经理和运营总监，可以根据这个指标，去尝试分析，整个网站，产品，各个页面的表现怎么样，是不是需要去优化产品的布局；吸引用户最终可以进入最后的支付页面。

数据分析师，可以此数据做更深一步的计算和分析企业管理层，可以看到整个公司的网站，各个页面的之间的跳转的表现如何，可以适当

调整公司的经营战略或策略。
在这里插入图片描述

object Spark06_Req3_PageflowAnalysis {

  def main(args: Array[String]): Unit = {
    //TODO :Top10热门品类
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("HotCategoryTop10Analysis")
    val sc = new SparkContext(sparkConf)

    //1.读取原始日志数量
    val actionRDD: RDD[String] = sc.textFile("datas/user_visit_action.txt")

    val actionDataRDD = actionRDD.map(
      action => {
        val datas: Array[String] = 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
        )
      }
    )

    actionDataRDD.cache()

    //TODO 对指定的页面连续跳转进行统计
    val 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(
      action => {
        //init不包含最后一个7
        ids.init.contains(action.page_id)
      }
    ).map(
      action => {
        (action.page_id, 1L)
      }
    ).reduceByKey(_ + _).collect().toMap


    //TODO 计算分子

    //根据session进行分组
    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]
        //[2,3,4] 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),sum)
    val dataRDD: RDD[((Long, Long), Int)] = 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,//用户的 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
}
逗×
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SparkSQL案例分析：电商平台用户行为分析
AI架构设计之禅
05-13 525
1. 背景介绍 1.1 电商平台用户行为分析的意义 在当今竞争激烈的电商市场，了解用户行为对于电商平台的成功至关重要。用户行为分析可以帮助电商平台： 个性化推荐: 根据用户的历史行为和偏好，推荐更相关的产品和服务，提高转化率。
基于spark的淘宝用户行为数据分析及其可视化研究
大数据
05-15 2020
淘宝用户购物数据分析 阿里云天池数据集2017-11-25~2017-12-03数据
【Spark】Spark电商数据分析
HR的博客
01-04 3325
Spark电商数据分析数据展示与分析需求：Top10 热门品类需求分析实现方法一实现方法二实现方法三实现方法四需求：Top10 热门品类中每个品类的 Top10 活跃 Session 统计需求：页面单跳统计什么是页面单跳统计页面单跳的意义 数据展示与分析 上面的数据图是从数据文件中截取的一部分内容，表示为电商网站的用户行为数据，主要包含用户的 4 种行为：搜索，点击，下单，支付。数据规则如下： ➢ 数据文件中每行数据采用下划线分隔数据 ➢ 每一行数据表示用户的一次行为，这个行为只能是 4 种行为的一种.
Spark 案例（依据电商网站的真实需求）
Faith_xzc
08-21 1631
目录数据说明需求1：Top10 热门品类需求说明实现方案一需求分析需求实现实现方案二需求分析需求实现实现方案三需求分析需求实现需求 2：Top10 热门品类中每个品类的 Top10 活跃Session 统计需求说明需求分析需求实现 数据说明 在前面的博客中已经介绍了了 Spark 的基础编程方式，接下来，再看下在实际的工作中如何使用这些 API 实现具体的需求。这些需求是电商网站的真实需求，所以在实现功能前，先将数据准备好。 数据文档链接 提取码：xzc6 上面的数据图是从数据文件中截取的一部分内容，表示
BigData之Spark：Spark(大数据通用的分布式开源计算引擎)的简介、下载、经典案例之详细攻略
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
01-08 4318
​ BigData之Spark：Spark(大数据通用的分布式开源计算引擎)的简介、下载、经典案例之详细攻略 目录 Spark的简介 Spark的下载 Spark的经典案例 Spark的简介 Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎。Spark是UC Berkeley AMP lab (加州大学伯克利分校的AMP实验室)所开源的类Hadoop MapReduce的通用并行框架，Spark，拥有Hadoop MapReduce所具有的优点；但
Spark入门之八：Spark Streaming 的原理以及应用场景介绍
不积跬步，无以至千里；不积小流，无以成江海！
11-10 9355
什么是Spark Streaming Spark Streaming类似于Apache Storm，用于流式数据的处理。根据其官方文档介绍，Spark Streaming有高吞吐量和容错能力强这两个特点。Spark Streaming支持的数据输入源很多，例如：Kafka、Flume、Twitter、ZeroMQ和简单的TCP套接字等等。数据输入后可以用 Spark的高度抽象原语如：map、re
Spark Streaming 订单关联案例剖析
codemosi的专栏，点击我可以跳到目录一栏
09-15 2451
发表于2015-08-03 14:45| 421次阅读| 来源未知| 0 条评论| 作者csdn 摘要：Apache Spark 是加州大学伯克利分校的 AMPLabs 开发的开源分布式轻量级通用计算框架。由于 Spark 基于内存设计，使得它拥有比 Hadoop 更高的性能(极端情况下可以达到 100x)，并且对多语言(Scala、Java、Python)提供支持。其一栈式
Spark 案例测试数据
09-11
Spark 案例测试数据Spark 案例测试数据Spark 案例测试数据Spark 案例测试数据Spark 案例测试数据Spark 案例测试数据Spark 案例测试数据Spark 案例测试数据Spark 案例测试数据Spark 案例测试数据Spark 案例测试数据...
Spark电商推荐项目源码.zip
09-28
《Spark在电商推荐系统中的应用深度解析》 在当今的电商行业中，个性化推荐系统已经成为提升用户体验、增加销售额的重要工具。本篇文章将深入探讨基于Spark的电商推荐系统，以"Spark电商推荐项目源码"为例，解析其...
spark大数据大型电商项目-spark-shopAnalyze.zip
11-04
《Spark在大数据电商项目中的应用——以"spark-shopAnalyze"为例》 在当今的数据驱动时代，大数据技术已经成为企业决策的重要支撑，特别是在电商领域。Spark作为一款高效、易用的大数据处理框架，因其强大的计算...
基于spark的电商用户行为分析系统.zip
最新发布
12-24
基于Spark开发的完整项目算法源码，可用于毕业设计、课程设计、练手学习等
大数据电商项目，视频（真实企业项目）
11-02
基于大数据生态圈对电商交易数据进行在线和离线的分析，大数据生态圈，视频教程，百度云分享。
Spark大型项目实战：电商用户行为分析大数据平台开发实战
07-12
1、项目中全面覆盖了Spark Core、Spark SQL和Spark Streaming这三个技术框架几乎全部的初级和高级的技术点和知识点， 让学员学以致用，通过一套课程，即掌握如何将Spark所有的技术点和知识点应用在真实的项目中，来...
Spark SQL商品订单案例
weixin_43629241的博客
05-25 2735
Spark SQL编程初级实践 1、编程实现以下功能。 （1）样例数据 样例数据说明：数据集是货品交易数据集。 每个订单可能包含多个货品，每个订单可以产生多次交易，不同的货品有不同的单价 （2）设计要求 1）加载数据 2）将加载的数据分别生成表 3）计算所有订单中每年的销售单数、销售总额 4）计算所有订单每年最大金额订单的销售额 5）计算所有订单中每年最畅销货品 （3）编程实现 先将三个文本数据转换成三个RDD,并清洗不符合条件的数据 val tbStockDetailRDD=sc.textFi
Spark 作业提交流程源码分析
bigdatakenan的博客
10-20 782
因为我们的环境是yarn-cluster环境，YarnClusterApplication继承了SparkApplication，所以上一步启动SparkApplication就会启动YarnClusterApplication，我们接下来看一下它的start方法,该方法中new了一个client对象后并调用它的run方法。这个方法中调用了submitApplication方法，返回一个appId,后面是对appId的相关判断和操作，所以下面我们可以看看submitApplication方法做了那些操作。
python 数据处理 - JSON模块
weixin_41535493的博客
10-16 396
python 数据处理 - JSON库 1.将字典保存为JSON格式数据 final_dict = {"version": 1, "battery": 2} json_result = json.dumps(final_dict) filename = 'result_temp.json' with open(filename,'w') as file_obj: json.dump(json.loads(json_result), file_obj, indent=4,
spark项目实战：电商分析平台之项目概述
努力努力再努力L
06-03 1719
电商分析平台之需求一：各个范围Session步长、访问时长占比统计 目录 项目概述 程序架构分析 需求解析 1. 项目概述 在访问电商网站时，我们的一些访问行为会产生相应的埋点日志（例如点击、搜索、下单、购买等），这些埋点日志会被发送给电商的后台服务器，大数据部门会根据这些埋点日志中的数据分析用户的访问行为，并得出一系列的统计指标，借助这些统计指标指导电商平台中的商品推荐、广告推送和网...
Spark实验案例
qq_36365123的博客
06-08 3143
一、实验目的 （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综合项目：企业电商分析平台
Zeroowt的博客
06-14 1378
1. 背景说明 2. 系统架构 3.业务分析 4.需求编码 5.技术总结
hive on spark在实际电商业务中的一些优化
06-11
Hive on Spark 在实际电商业务中可以通过以下一些优化来提高性能和效率： 1. 设置适当的资源：在使用 Spark 作为计算引擎时，为了保证 Hive on Spark 的性能和效率，需要为 Spark Executor 分配适当的资源，包括 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值