基于SparkSQL的电影分析项目实战

最新推荐文章于 2024-03-03 00:06:19 发布
最新推荐文章于 2024-03-03 00:06:19 发布
阅读量2k 收藏 31
点赞数 2
分类专栏： # Spark 文章标签： java
原文链接：https://so.csdn.net/so/search?q=%E5%AE%A2%E5%BF%AB%E7%89%A9%E6%B5%81&t=&u=
版权

在本篇分享中，将介绍一个完整的项目案例，该案例会真实还原企业中SparkSQL的开发流程，手把手教你构建一个基于SparkSQL的分析系统。为了讲解方便，我会对代码进行拆解，完整的代码已上传至GitHub，想看完整代码可以去clone，顺便给个**图片Star**。以下是全文，希望本文对你有所帮助。看完记得三连：图片分享、图片点赞、图片在看

https://github.com/jiamx/spark_project_practise

项目介绍

数据集介绍

使用MovieLens的名称为ml-25m.zip的数据集，使用的文件时movies.csv和ratings.csv，上述文件的下载地址为：

http://files.grouplens.org/datasets/movielens/ml-25m.zip
  • movies.csv

该文件是电影数据，对应的为维表数据，大小为2.89MB，包括6万多部电影，其数据格式为[movieId,title,genres],分别对应[电影id，电影名称，电影所属分类]，样例数据如下所示：逗号分隔

1,Toy Story (1995),Adventure|Animation|Children|Comedy|Fantasy
  • ratings.csv

该文件为定影评分数据，对应为事实表数据，大小为646MB，其数据格式为:[userId,movieId,rating,timestamp],分别对应[用户id，电影id，评分，时间戳]，样例数据如下所示：逗号分隔

1,296,5,1147880044

项目代码结构

图片

需求分析

  • 需求1：查找电影评分个数超过5000,且平均评分较高的前十部电影名称及其对应的平均评分

图片

  • 需求2：查找每个电影类别及其对应的平均评分

图片

  • 需求3：查找被评分次数较多的前十部电影

图片

代码讲解

  • DemoMainApp

该类是程序执行的入口，主要是获取数据源，转换成DataFrame，并调用封装好的业务逻辑类。

object DemoMainApp {
  // 文件路径
  private val MOVIES_CSV_FILE_PATH = "file:///e:/movies.csv"
  private val RATINGS_CSV_FILE_PATH = "file:///e:/ratings.csv"

  def main(args: Array[String]): Unit = {
    // 创建spark session
    val spark = SparkSession
      .builder
      .master("local[4]")
      .getOrCreate
    // schema信息
    val schemaLoader = new SchemaLoader
    // 读取Movie数据集
    val movieDF = readCsvIntoDataSet(spark, MOVIES_CSV_FILE_PATH, schemaLoader.getMovieSchema)
    // 读取Rating数据集
    val ratingDF = readCsvIntoDataSet(spark, RATINGS_CSV_FILE_PATH, schemaLoader.getRatingSchema)

    // 需求1：查找电影评分个数超过5000,且平均评分较高的前十部电影名称及其对应的平均评分
    val bestFilmsByOverallRating = new BestFilmsByOverallRating
    //bestFilmsByOverallRating.run(movieDF, ratingDF, spark)

    // 需求2：查找每个电影类别及其对应的平均评分
    val genresByAverageRating = new GenresByAverageRating
    //genresByAverageRating.run(movieDF, ratingDF, spark)

    // 需求3：查找被评分次数较多的前十部电影
    val mostRatedFilms = new MostRatedFilms
    mostRatedFilms.run(movieDF, ratingDF, spark)

    spark.close()

  }
  /**
    * 读取数据文件，转成DataFrame
    *
    * @param spark
    * @param path
    * @param schema
    * @return
    */
  def readCsvIntoDataSet(spark: SparkSession, path: String, schema: StructType) = {

    val dataSet = spark.read
      .format("csv")
      .option("header", "true")
      .schema(schema)
      .load(path)
    dataSet
  }
}
  • Entry

该类为实体类，封装了数据源的样例类和结果表的样例类

class Entry {

}

case class Movies(
                   movieId: String, // 电影的id
                   title: String, // 电影的标题
                   genres: String // 电影类别
                 )

case class Ratings(
                    userId: String, // 用户的id
                    movieId: String, // 电影的id
                    rating: String, // 用户评分
                    timestamp: String // 时间戳
                  )

// 需求1MySQL结果表
case class tenGreatestMoviesByAverageRating(
                                             movieId: String, // 电影的id
                                             title: String, // 电影的标题
                                             avgRating: String // 电影平均评分
                                           )

// 需求2MySQL结果表
case class topGenresByAverageRating(
                                     genres: String, //电影类别
                                     avgRating: String // 平均评分
                                   )

// 需求3MySQL结果表
case class tenMostRatedFilms(
                              movieId: String, // 电影的id
                              title: String, // 电影的标题
                              ratingCnt: String // 电影被评分的次数
                            )
  • SchemaLoader

该类封装了数据集的schema信息，主要用于读取数据源是指定schema信息

class SchemaLoader {
  // movies数据集schema信息
  private val movieSchema = new StructType()
    .add("movieId", DataTypes.StringType, false)
    .add("title", DataTypes.StringType, false)
    .add("genres", DataTypes.StringType, false)
 // ratings数据集schema信息
  private val ratingSchema = new StructType()
    .add("userId", DataTypes.StringType, false)
    .add("movieId", DataTypes.StringType, false)
    .add("rating", DataTypes.StringType, false)
    .add("timestamp", DataTypes.StringType, false)

  def getMovieSchema: StructType = movieSchema

  def getRatingSchema: StructType = ratingSchema
}
  • JDBCUtil

该类封装了连接MySQL的逻辑，主要用于连接MySQL，在业务逻辑代码中会使用该工具类获取MySQL连接，将结果数据写入到MySQL中。

object JDBCUtil {
  val dataSource = new ComboPooledDataSource()
  val user = "root"
  val password = "123qwe"
  val url = "jdbc:mysql://localhost:3306/mydb"

  dataSource.setUser(user)
  dataSource.setPassword(password)
  dataSource.setDriverClass("com.mysql.jdbc.Driver")
  dataSource.setJdbcUrl(url)
  dataSource.setAutoCommitOnClose(false)
// 获取连接
  def getQueryRunner(): Option[QueryRunner]={
    try {
      Some(new QueryRunner(dataSource))
    }catch {
      case e:Exception =>
        e.printStackTrace()
        None
    }
  }
}

需求1实现

  • BestFilmsByOverallRating

需求1实现的业务逻辑封装。该类有一个run()方法，主要是封装计算逻辑。

/**
  * 需求1：查找电影评分个数超过5000,且平均评分较高的前十部电影名称及其对应的平均评分
  */
class BestFilmsByOverallRating extends Serializable {

  def run(moviesDataset: DataFrame, ratingsDataset: DataFrame, spark: SparkSession) = {
    import spark.implicits._

    // 将moviesDataset注册成表
    moviesDataset.createOrReplaceTempView("movies")
    // 将ratingsDataset注册成表
    ratingsDataset.createOrReplaceTempView("ratings")

    // 查询SQL语句
    val ressql1 =
      """
         |WITH ratings_filter_cnt AS (
         |SELECT
         |     movieId,
         |     count( * ) AS rating_cnt,
         |     avg( rating ) AS avg_rating
         |FROM
         |     ratings
         |GROUP BY
         |     movieId
         |HAVING
         |     count( * ) >= 5000
         |),
         |ratings_filter_score AS (
         |SELECT
         |     movieId, -- 电影id
         |     avg_rating -- 电影平均评分
         |FROM ratings_filter_cnt
         |ORDER BY avg_rating DESC -- 平均评分降序排序
         |LIMIT 10 -- 平均分较高的前十部电影
         |)
         |SELECT
         |    m.movieId,
         |    m.title,
         |    r.avg_rating AS avgRating
         |FROM
         |   ratings_filter_score r
         |JOIN movies m ON m.movieId = r.movieId
      """.stripMargin

    val resultDS = spark.sql(ressql1).as[tenGreatestMoviesByAverageRating]
    // 打印数据
    resultDS.show(10)
    resultDS.printSchema()
    // 写入MySQL
    resultDS.foreachPartition(par => par.foreach(insert2Mysql(_)))
  }

  /**
    * 获取连接，调用写入MySQL数据的方法
    *
    * @param res
    */
  private def insert2Mysql(res: tenGreatestMoviesByAverageRating): Unit = {
    lazy val conn = JDBCUtil.getQueryRunner()
    conn match {
      case Some(connection) => {
        upsert(res, connection)
      }
      case None => {
        println("Mysql连接失败")
        System.exit(-1)
      }
    }
  }

  /**
    * 封装将结果写入MySQL的方法
    * 执行写入操作
    *
    * @param r
    * @param conn
    */
  private def upsert(r: tenGreatestMoviesByAverageRating, conn: QueryRunner): Unit = {
    try {
      val sql =
        s"""
           |REPLACE INTO `ten_movies_averagerating`(
           |movieId,
           |title,
           |avgRating
           |)
           |VALUES
           |(?,?,?)
       """.stripMargin
      // 执行insert操作
      conn.update(
        sql,
        r.movieId,
        r.title,
        r.avgRating
      )
    } catch {
      case e: Exception => {
        e.printStackTrace()
        System.exit(-1)
      }
    }
  }
}

需求1结果

  • 结果表建表语句
CREATE TABLE `ten_movies_averagerating` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '自增id',
  `movieId` int(11) NOT NULL COMMENT '电影id',
  `title` varchar(100) NOT NULL COMMENT '电影名称',
  `avgRating` decimal(10,2) NOT NULL COMMENT '平均评分',
  `update_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`),
  UNIQUE KEY `movie_id_UNIQUE` (`movieId`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8;
  • 统计结果

平均评分最高的前十部电影如下：

movieIdtitleavgRating
318Shawshank Redemption, The (1994)4.41
858Godfather, The (1972)4.32
50Usual Suspects, The (1995)4.28
1221Godfather: Part II, The (1974)4.26
527Schindler’s List (1993)4.25
2019Seven Samurai (Shichinin no samurai) (1954)4.25
904Rear Window (1954)4.24
120312 Angry Men (1957)4.24
2959Fight Club (1999)4.23
1193One Flew Over the Cuckoo’s Nest (1975)4.22

上述电影评分对应的电影中文名称为：

英文名称中文名称
Shawshank Redemption, The (1994)肖申克的救赎
Godfather, The (1972)教父1
Usual Suspects, The (1995)非常嫌疑犯
Godfather: Part II, The (1974)教父2
Schindler’s List (1993)辛德勒的名单
Seven Samurai (Shichinin no samurai) (1954)七武士
Rear Window (1954)后窗
12 Angry Men (1957)十二怒汉
Fight Club (1999)搏击俱乐部
One Flew Over the Cuckoo’s Nest (1975)飞越疯人院

需求2实现

  • GenresByAverageRating

需求2实现的业务逻辑封装。该类有一个run()方法，主要是封装计算逻辑。

**
  * 需求2：查找每个电影类别及其对应的平均评分
  */
class GenresByAverageRating extends Serializable {
  def run(moviesDataset: DataFrame, ratingsDataset: DataFrame, spark: SparkSession) = {
    import spark.implicits._
    // 将moviesDataset注册成表
    moviesDataset.createOrReplaceTempView("movies")
    // 将ratingsDataset注册成表
    ratingsDataset.createOrReplaceTempView("ratings")

    val ressql2 =
      """
        |WITH explode_movies AS (
        |SELECT
        | movieId,
        | title,
        | category
        |FROM
        | movies lateral VIEW explode ( split ( genres, "\\|" ) ) temp AS category
        |)
        |SELECT
        | m.category AS genres,
        | avg( r.rating ) AS avgRating
        |FROM
        | explode_movies m
        | JOIN ratings r ON m.movieId = r.movieId
        |GROUP BY
        | m.category
        | """.stripMargin

    val resultDS = spark.sql(ressql2).as[topGenresByAverageRating]

    // 打印数据
    resultDS.show(10)
    resultDS.printSchema()
    // 写入MySQL
    resultDS.foreachPartition(par => par.foreach(insert2Mysql(_)))

  }

  /**
    * 获取连接，调用写入MySQL数据的方法
    *
    * @param res
    */
  private def insert2Mysql(res: topGenresByAverageRating): Unit = {
    lazy val conn = JDBCUtil.getQueryRunner()
    conn match {
      case Some(connection) => {
        upsert(res, connection)
      }
      case None => {
        println("Mysql连接失败")
        System.exit(-1)
      }
    }
  }

  /**
    * 封装将结果写入MySQL的方法
    * 执行写入操作
    *
    * @param r
    * @param conn
    */
  private def upsert(r: topGenresByAverageRating, conn: QueryRunner): Unit = {
    try {
      val sql =
        s"""
           |REPLACE INTO `genres_average_rating`(
           |genres,
           |avgRating
           |)
           |VALUES
           |(?,?)
       """.stripMargin
      // 执行insert操作
      conn.update(
        sql,
        r.genres,
        r.avgRating
      )
    } catch {
      case e: Exception => {
        e.printStackTrace()
        System.exit(-1)
      }
    }
  }
}

需求2结果

  • 结果表建表语句
CREATE TABLE genres_average_rating (
    `id` INT ( 11 ) NOT NULL AUTO_INCREMENT COMMENT '自增id',
    `genres` VARCHAR ( 100 ) NOT NULL COMMENT '电影类别',
    `avgRating` DECIMAL ( 10, 2 ) NOT NULL COMMENT '电影类别平均评分',
    `update_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY ( `id` ),
UNIQUE KEY `genres_UNIQUE` ( `genres` )
) ENGINE = INNODB DEFAULT CHARSET = utf8;
  • 统计结果

共有20个电影分类，每个电影分类的平均评分为：

genresavgRating
Film-Noir3.93
War3.79
Documentary3.71
Crime3.69
Drama3.68
Mystery3.67
Animation3.61
IMAX3.6
Western3.59
Musical3.55
Romance3.54
Adventure3.52
Thriller3.52
Fantasy3.51
Sci-Fi3.48
Action3.47
Children3.43
Comedy3.42
(no genres listed)3.33
Horror3.29

电影分类对应的中文名称为：

分类中文名称
Film-Noir黑色电影
War战争
Documentary纪录片
Crime犯罪
Drama历史剧
Mystery推理
Animation动画片
IMAX巨幕电影
Western西部电影
Musical音乐
Romance浪漫
Adventure冒险
Thriller惊悚片
Fantasy魔幻电影
Sci-Fi科幻
Action动作
Children儿童
Comedy喜剧
(no genres listed)未分类
Horror恐怖

需求3实现

  • MostRatedFilms

    需求3实现的业务逻辑封装。该类有一个run()方法，主要是封装计算逻辑。

/**
  * 需求3：查找被评分次数较多的前十部电影.
  */
class MostRatedFilms extends Serializable {
   def run(moviesDataset: DataFrame, ratingsDataset: DataFrame,spark: SparkSession) = {

     import spark.implicits._

     // 将moviesDataset注册成表
     moviesDataset.createOrReplaceTempView("movies")
     // 将ratingsDataset注册成表
     ratingsDataset.createOrReplaceTempView("ratings")

val ressql3 =
  """
    |WITH rating_group AS (
    |    SELECT
    |       movieId,
    |       count( * ) AS ratingCnt
    |    FROM ratings
    |    GROUP BY movieId
    |),
    |rating_filter AS (
    |    SELECT
    |       movieId,
    |       ratingCnt
    |    FROM rating_group
    |    ORDER BY ratingCnt DESC
    |    LIMIT 10
    |)
    |SELECT
    |    m.movieId,
    |    m.title,
    |    r.ratingCnt
    |FROM
    |    rating_filter r
    |JOIN movies m ON r.movieId = m.movieId
    |
  """.stripMargin

     val resultDS = spark.sql(ressql3).as[tenMostRatedFilms]
     // 打印数据
     resultDS.show(10)
     resultDS.printSchema()
     // 写入MySQL
     resultDS.foreachPartition(par => par.foreach(insert2Mysql(_)))

  }

  /**
    * 获取连接，调用写入MySQL数据的方法
    *
    * @param res
    */
  private def insert2Mysql(res: tenMostRatedFilms): Unit = {
    lazy val conn = JDBCUtil.getQueryRunner()
    conn match {
      case Some(connection) => {
        upsert(res, connection)
      }
      case None => {
        println("Mysql连接失败")
        System.exit(-1)
      }
    }
  }

  /**
    * 封装将结果写入MySQL的方法
    * 执行写入操作
    *
    * @param r
    * @param conn
    */
  private def upsert(r: tenMostRatedFilms, conn: QueryRunner): Unit = {
    try {
      val sql =
        s"""
           |REPLACE INTO `ten_most_rated_films`(
           |movieId,
           |title,
           |ratingCnt
           |)
           |VALUES
           |(?,?,?)
       """.stripMargin
      // 执行insert操作
      conn.update(
        sql,
        r.movieId,
        r.title,
        r.ratingCnt
      )
    } catch {
      case e: Exception => {
        e.printStackTrace()
        System.exit(-1)
      }
    }
  }

}

需求3结果

  • 结果表创建语句
CREATE TABLE ten_most_rated_films (
    `id` INT ( 11 ) NOT NULL AUTO_INCREMENT COMMENT '自增id',
    `movieId` INT ( 11 ) NOT NULL COMMENT '电影Id',
    `title` varchar(100) NOT NULL COMMENT '电影名称',
    `ratingCnt` INT(11) NOT NULL COMMENT '电影被评分的次数',
    `update_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY ( `id` ),
UNIQUE KEY `movie_id_UNIQUE` ( `movieId` )
) ENGINE = INNODB DEFAULT CHARSET = utf8;
  • 统计结果
movieIdtitleratingCnt
356Forrest Gump (1994)81491
318Shawshank Redemption, The (1994)81482
296Pulp Fiction (1994)79672
593Silence of the Lambs, The (1991)74127
2571Matrix, The (1999)72674
260Star Wars: Episode IV - A New Hope (1977)68717
480Jurassic Park (1993)64144
527Schindler’s List (1993)60411
110Braveheart (1995)59184
2959Fight Club (1999)58773

评分次数较多的电影对应的中文名称为：

英文名称中文名称
Forrest Gump (1994)阿甘正传
Shawshank Redemption, The (1994)肖申克的救赎
Pulp Fiction (1994)低俗小说
Silence of the Lambs, The (1991)沉默的羔羊
Matrix, The (1999)黑客帝国
Star Wars: Episode IV - A New Hope (1977)星球大战
Jurassic Park (1993)侏罗纪公园
Schindler’s List (1993)辛德勒的名单
Braveheart (1995)勇敢的心
Fight Club (1999)搏击俱乐部

总结

本文主要是基于SparkSQL对MovieLens数据集进行统计分析，完整实现了三个需求，并给对每个需求都给出了详细的代码实现和结果分析。本案例还原了企业使用SparkSQL进行实现数据统计的基本流程，通过本文，或许你对SparkSQL的应用有了更加深刻的认识，希望本文对你有所帮助。

AI+Maynor
关注
  • 2
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第十一篇|基于SparkSQL的电影分析项目实战
jmx_bigdata的博客
11-23 3185
在之前的分享中，曾系统地介绍了Spark的基本原理和使用方式，感兴趣的可以翻看之前的分享文章。在本篇分享中，将介绍一个完整的项目案例，该案例会真实还原企业中SparkSQL的开发流程，手把手教你构建一个基于SparkSQL的分析系统。为了讲解方便，我会对代码进行拆解，完整的代码已上传至GitHub，想看完整代码可以去clone，记得给个Star。以下是全文，希望本文对你有所帮助。 https://github.com/jiamx/spark_project_practise 公众号『大数据技术与数仓』，
基于spark的电影点评系统
04-08
该项目是我大三下学期的课程设计，主要实现一个基于Spark实现电影点评系统用户行为分析，用户可以对自己已经看过的电影做出一定的评价，然后对这些观影数据信息进行分析。
《Spark机器学习》笔记——基于MovieLens数据集使用Spark进行电影数据分析
陈杰
01-02 6722
1、数据集下载https://grouplens.org/datasets/movielens2、数据集下文件格式u.user用户属性文件包含user.id用户ID    gender性别   occupation职业    ZIP code邮编等属性，每个属性之间用|分割u.item电影元数据包含movie.id电影ID    title电影标题    release date电影上映日期
大数据毕业设计Hadoop+Spark电影推荐系统 电影评论情感分析 电影用户画像系统 电影评论情感分析 电影爬虫 电影可视化 电影数据分析 计算机毕业设计 深度学习 机器学习 人工智能 知识图谱
最新发布
从业计算机毕业设计10年，打算用一年时间分享10年毕设经验！
03-03 582
大数据毕业设计Hadoop+Spark电影推荐系统 电影评论情感分析 电影用户画像系统 电影评论情感分析 电影爬虫 电影可视化 电影数据分析 计算机毕业设计 深度学习 机器学习 人工智能 知识图谱
XSQL：基于SparkSQL的统一SQL分析引擎
01-30
| XSQL是一种易于使用，运行稳定的多数据源查询引擎。1）首先，XSQL提供了一种使用标准SQL从NoSQL数据库读取数据的解决方案，因此大数据工程师可以专注于数据，而API具有特殊数据源。 2）XSQL致力于优化SQL执行的执行计划以及监视每个SQL的运行状态，从而使用户的工作运行更健康。 产品特点 XSQL现在支持八个内置数据源（例如，Hive，Mysql，EleasticSearch，Mongo，Kafka，Hbase，Redis，Druid）。 XSQL设计了一个3-layer metadata architecture来组织数据，即数据源-数据库表。 因此，我们可以提供许多数据源的统一视图，而不再需要在离线数据和在线数据之间进行业务分析。 XSQL的主要思想是SQL Everything ，SQL让程序与具体的数据源API分离，因此DBA可以升级数据，但需要考虑如何迁移旧任务。 更重要的是，数据分析人员更喜欢SQL而不是特殊的API。 XSQL仅在必要时使用YARN群集资源，此功能对某些使用情况很有用，例如用户将spark-xsql替换为RDMS Client。 我们
基于Spark的电影数据集分析
06-24
该项目是大三下学期的课程设计，使用的数据集来自知名数据网站 Kaggle 的 tmdb-movie-metadata 电影数据集，以Python为编程语言，使用大数据框架Spark对数据进行了预处理，然后分别从多个方面对数据进行了分类和分析，并对分析结果进行可视化。里面包含我的课程设计报告和完整的代码。希望对你们有帮助。
基于Spark的零售交易数据分析
06-24
该项目是大三下学期的课程设计，选取了共541909条数据，以Python为编程语言，使用大数据框架Spark对数据进行了预处理，然后分别从多个方面对数据进行了分类和分析，并对分析结果进行可视化。里面包含我的课程设计报告和完整的代码。希望对你们有帮助。
基于spark的电影数据分析
毕业作品网站
10-10 5849
在对大数据的深入研究后，根据其前景，包括数据方面的发展与价值，本套系统从用户痛点需求进行分析入手，对系统架构进行了设计，随后完成了系统方面的具体设计，最后为数据入库对DB进行配置和设计，最后到系统搭建和编码实现，分别为后台数据处理，在数据转换方面包括数据的clean、临时存储落地，数据经过完全处理后入库，和前台的ECharts可视化系统，对处理后落地的数据使用饼图进行可视化展现。大数据系统的结构设计、系统总体设计、系统功能模块划分、系统功能模块需求、数据库设计概述、数据库概览结构设计、数据逻辑结构设计。
使用SparkSQL的电影分析
yang灬仔
05-15 2029
项目介绍 数据集介绍 使用MovieLens的名称为ml-25m.zip的数据集，使用的文件时movies.csv和ratings.csv，上述文件的下载地址为： http://files.grouplens.org/datasets/movielens/ml-25m.zip movies.csv 该文件是电影数据，对应的为维表数据，大小为2.89MB，包括6万多部电影，其数据格式为[movieId,title,genres],分别对应[电影id，电影名称，电影所属分类]，样例数据如下所
大数据Spark电影评分数据分析
赵广陆
08-24 6990
目录1 数据 ETL2 使用 SQL 分析3 使用 DSL 分析4 保存结果数据5 案例完整代码6 Shuffle 分区数目问题 1 数据 ETL 使用电影评分数据进行数据分析，分别使用DSL编程和SQL编程，熟悉数据处理函数及SQL使用，业务需求说明：对电影评分数据进行统分析，获取Top10电影（电影评分平均值最高，并且每个电影被评分的次数大于2000)。数据集ratings.dat总共100万条数据，数据格式如下每行数据各个字段之间使用双冒号分开： 数据处理分析步骤如下： 1. 第一步、读取电影评分
Spark大型项目实战：电商用户行为分析大数据平台开发实战
07-12
上百节课详细讲解，需要的小伙伴自行百度网盘下载，链接见附件，永久有效。 课程介绍： 讲解一个真实的、复杂的大型企业级大数据项目，是Spark的大型项目实战课程。 通过本套课程的学习，可以积累大量Spark项目经验，迈入Spark高级开发行列。 课程特色： 1、项目中全面覆盖了Spark Core、Spark SQL和Spark Streaming这三个技术框架几乎全部的初级和高级的技术点和知识点， 让学员学以致用，通过一套课程，即掌握如何将Spark所有的技术点和知识点应用在真实的项目中，来实现业务需求！ 2、项目中的4个功能横块，全郃是实际企业项目中提取出来的，并进行技术整合和改良过的功能模块.全都是企业级的复杂和真实的需求，业务模块非常之复杂，绝对不是市面上的Dem级别的大数据项目能够想比拟的，学习过后，真正帮助学员增加实际 企业级项目的实战经验。 3、项目中通过实际的功能模块和业务场景，以及讲师曾经开发过的处理十亿、甚至百亿以上数据级别的SparK作业的经验积累，贯穿讲解了大量的高级复杂的性能调优技术和知识、troubleshooting解决线上报错和故障的经验、高端的全方位数据倾斜处理和解决方案.真正帮助学员掌握高精尖的Spark技术！ 4、项目中采用完全还原企业大数据项目开发场景的方式来讲解，每一个业务模块的讲解都包括了需求分析、方案设计、数据设计、编码实现、功能测试、性能调优等环节，真实还原企业级大数据项目开发场景。 模块简介： 1、用户访问session分析,该模块主要是对用户访问session进行统计分析.包括session的聚合指标计算、 按时间比例随机抽取session、获取每天点击、下单和购买排名前10的品类、并获取top10品类的点击量排名前10的session.该模块可以让产品经理、数据分析师以及企业管理层形象地看到各种条件下的具体用户行为以及统计指标.从而对公司的产品设计以及业务发展战略做出调整.主要使用Spark Core实现. 2、页面单跳转化率统计,该模块主要是计算关键页面之间的单步跳转转化率，涉及到页面切片算法以及页面流匹配算法.该模块可以让产品经理、数据分析师以及企业管理层看到各个关键页面之间的转化率.从而对网页布局，进行更好的优化设计。主要使用Spark Core实现. 3、热门商品离线统计,该模块主要实现每天统计出各个区域的top3热门商品.然后使用Oozie进行离线统计任务的定时调度，使用Zeppeline进行数据可视化的报表展示.该模块可以让企业管理层看到公司售卖的 商品的整体情况，从而对公司的商品相关的战略进行调螫.主要使用Spark SQL实现。 4、广告流量实时统计.该模块负责实时统计公司的广告流量.包括广告展现流量和广告点击流量，实现动态黑名单机制以及黑名单过滤,实现滑动窗口内的各城市的广告展现流立和广告点击流直的统计，实现 每个区域诲个广告的点击流置实时统计，实现每个区域top3点击量的广告的统计,主要使用Spark Streaming实现.
sparksql小项目实战测试数据.zip
11-08
sparksql小案例测试数据
SparkSQL源码分析之核心流程
03-03
自从去年SparkSubmit2013MichaelArmbrust分享了他的Catalyst，到至今1年多了,SparkSQL的贡献者从几人到了几十人，而且发展速度异常迅猛，究其原因，个人认为有以下2点：1、整合：将SQL类型的查询语言整合到Spark的核心RDD概念里。这样可以应用于多种任务，流处理，批处理，包括机器学习里都可以引入Sql。2、效率：因为Shark受到hive的编程模型限制，无法再继续优化来适应Spark模型里。前一段时间测试过Shark，并且对SparkSQL也进行了一些测试，但是还是忍不住对SparkSQL一探究竟，就从源代码的角度来看一下SparkSQL的核心执行流程
基于豆瓣电影爬虫及Spark数据分析可视化设计
11-01
开发环境：PyCharm + Python3.7 + Spark + Idea + Mysql + Echart 可视化网站入口：http://localhost:8080/login.html 账号密码： admin/1 由于我国经济的不断增长，人们的物质生活也在不断提升，因此越来越多的人观影需求增加以丰富精神生活，为分析当下用户的观影偏好以及方便人们从众多的影片中作出合适的选择，本文基于Spark分析平台及python爬虫技术等设计了一个豆瓣电影数据分析可视化系统，以完成对豆瓣电影网页的数据进行爬取，进而以折线图图、直方图等多种数据可视化的形式直观的展示给用户，从而分析用户观影偏好以及为用户选择影片时提供一定的参考。 该豆瓣电影数据分析分析可视化系统主要可以实现至少对一万条电影数据的爬取和分析，可以从中分析出热门电影类型数据占比、历年电影上线走势、电影高频词统计分析、电影评分等级分析、影评时间统计分析、上线电影数量较高年份五大模块。
Java基于Spark2.x新闻网大数据实时分析可视化系统项目源码.zip
09-18
Java基于Spark2.x新闻网大数据实时分析可视化系统项目源码.zip 代码完整下载可用，期末大作业和课程设计都适用。 Java基于Spark2.x新闻网大数据实时分析可视化系统项目源码.zip 代码完整下载可用，期末大作业和课程设计都适用。Java基于Spark2.x新闻网大数据实时分析可视化系统项目源码.zip 代码完整下载可用，期末大作业和课程设计都适用。Java基于Spark2.x新闻网大数据实时分析可视化系统项目源码.zip 代码完整下载可用，期末大作业和课程设计都适用。Java基于Spark2.x新闻网大数据实时分析可视化系统项目源码.zip 代码完整下载可用，期末大作业和课程设计都适用。Java基于Spark2.x新闻网大数据实时分析可视化系统项目源码.zip 代码完整下载可用，期末大作业和课程设计都适用。Java基于Spark2.x新闻网大数据实时分析可视化系统项目源码.zip 代码完整下载可用，期末大作业和课程设计都适用。Java基于Spark2.x新闻网大数据实时分析可视化系统项目源码.zip 代码完整下载可用，期末大作业和课程设计都适用。Java基于Sp
基于Spark和Hive进行的豆瓣电影数据分析
weixin_34077371的博客
08-23 3326
写在前边的话： 算是自己做的一个小课题吧，自己搭建平台，自己爬取数据，自己进行数据清洗和分析，自己进行可视化展示，写这篇博客不为别的，只是记录下自己做这个课题的整个过程，大神们勿喷 环境说明：hadoop2.7集群，包含Hbase，Hive，Spark，Sqoop，Mahout组件 过 程：平台部署-...
Spark综合学习笔记（二十五）SparkSQL实战7-电影数据分析
斯特凡今天也很帅的博客
11-30 957
学习致谢 https://www.bilibili.com/video/BV1Xz4y1m7cv?p=63 需求： 对电影评分数据进行统计分析，分别使用DSL编程和5QL编程，获取电影平均分Top10，要求电影的评分次数大于200 代码实现 package sql import java.util.Properties import org.apache.spark.sql.{DataFrame, Dataset, SaveMode, SparkSession} /** * Author itc
基于电影爬虫及Spark数据分析可视化设计-计算机毕业源码设计
计算机源码设计案例的博客
11-06 3760
由于我国经济的不断增长，人们的物质生活也在不断提升，因此越来越多的人观影需求增加以丰富精神生活，为分析当下用户的观影偏好以及方便人们从众多的影片中作出合适的选择，本文基于Spark分析平台及python爬虫技术等设计了一个豆瓣电影数据分析可视化系统，以完成对豆瓣电影网页的数据进行爬取，进而以折线图图、直方图等多种数据可视化的形式直观的展示给用户，从而分析用户观影偏好以及为用户选择影片时提供一定的参考。
presto、druid、sparksql、kylin的对比分析
03-16
Presto、Druid、SparkSQL、Kylin是四种不同的分布式计算引擎，它们都可以用于大数据处理和分析。下面是它们的对比分析： 1. Presto：Presto是一个分布式SQL查询引擎，它可以在多个数据源上执行查询，包括Hadoop、Hive、MySQL等。Presto的优点是速度快、支持复杂查询、易于扩展和部署。缺点是不支持实时数据处理和数据仓库建模。 2. Druid：Druid是一个实时数据处理和分析引擎，它可以处理大量的实时数据，并提供快速的查询和聚合功能。Druid的优点是速度快、支持实时数据处理和多维度分析、易于扩展和部署。缺点是不支持复杂查询和数据仓库建模。 3. SparkSQL：SparkSQL是Apache Spark的一个模块，它提供了一个SQL查询引擎，可以在Spark集群上执行SQL查询。SparkSQL的优点是速度快、支持复杂查询、易于扩展和部署。缺点是不支持实时数据处理和数据仓库建模。 4. Kylin：Kylin是一个OLAP引擎，它可以将Hadoop上的数据转换为多维数据模型，并提供快速的查询和分析功能。Kylin的优点是支持复杂查询和多维度分析、易于扩展和部署。缺点是不支持实时数据处理和数据仓库建模。 综上所述，这四种分布式计算引擎各有优缺点，选择哪种引擎取决于具体的业务需求和数据处理场景。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值