From d956be715456c710e1893c1160da3a0a8d06ff0f Mon Sep 17 00:00:00 2001 From: kennethcheng Date: Mon, 21 Sep 2026 00:36:09 +0800 Subject: [PATCH] =?UTF-8?q?docs:README=E6=9B=B4=E6=96=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 1062 +++++++++++++++++++++++------------------------------ 1 file changed, 460 insertions(+), 602 deletions(-) diff --git a/README.md b/README.md index 1e18e4a..e2f5c1c 100644 --- a/README.md +++ b/README.md @@ -1,405 +1,154 @@ # Spark 学习项目 -基于 **Scala + Java** 的 Apache Spark 学习与练习项目。 +> 仓库：[`KennethCheng/spark_20260915`](https://gitea.kennethcheng.cc/KennethCheng/spark_20260915) -本项目主要用于个人学习和记录 Spark，从 Spark 基础、RDD、PairRDD、Shuffle、Partition 逐步深入，同时保留线下课程中的 DataFrame、缓存、Checkpoint、YARN 提交等示例代码。 +这是我的 **Scala + Spark 学习与练习项目**，主要用于记录跟随课程学习 Spark 的过程，并把课堂 Demo、课后练习和实际运行实验整理到同一个 Maven 项目中。 -项目以 **Scala 为主，Java 为辅**，代码按照课程进行拆分，每一课尽量保持独立，方便学习、复习和实验。 +当前学习重点以 **Spark Core / RDD** 为主，并逐步过渡到 **Spark SQL / DataFrame / Hive / JDBC**。 --- -## 项目目标 +## 学习方式 -通过循序渐进的练习掌握 Spark Core 的核心概念，并逐步过渡到 Spark SQL。 +项目中的代码主要分成两类： -学习重点包括： +- `chapter`：线下课程内容、课堂 Demo、知识点验证 +- `practise`：配合 ChatGPT 学习完成的课后练习 -- Spark 应用程序的基本结构 -- `SparkConf`、`SparkContext` -- RDD 的创建、转换和行动 -- `map`、`filter`、`flatMap`、`reduce`、`foreach` -- PairRDD 与 `reduceByKey` -- `groupByKey` 与 `reduceByKey` -- Shuffle 的基本原理 -- RDD Partition 分区 -- `glom`、`repartition`、`coalesce` -- `partitionBy` -- 自定义 `Partitioner` -- WordCount -- Spark SQL / DataFrame -- Cache、Persist、Checkpoint -- Spark 程序打包及 YARN 提交 +代码统一放在 Maven 的 `src/main/scala` / `src/main/java` 下，尽量保持一个知识点一个 Demo，方便单独运行和复习。 + +提交信息统一使用中文，例如： + +```text +feat:线下课：集合_... +feat:ChatGPT第 7 课：缓存 Cache / Persist + mapPartitions +``` --- ## 技术栈 -| 技术 | 版本 / 说明 | +| 类别 | 版本 | | --- | --- | -| JDK | 8 | +| JDK | Java 8 | | Scala | 2.11.12 | | Apache Spark | 2.4.3 | | Hadoop Client | 2.7.3 | -| MySQL | 8.0.28 | +| Maven | Maven 3 | +| scala-maven-plugin | 4.8.1 | +| maven-assembly-plugin | 3.7.1 | +| MySQL Connector | 8.0.28 | | HikariCP | 4.0.3 | | commons-dbutils | 1.6 | -| JUnit | 3.8.1 | -| 构建工具 | Maven 3 | -| Scala Maven Plugin | 4.8.1 | -| Maven Assembly Plugin | 3.7.1 | -项目 `pom.xml` 当前固定使用 **Java 8 + Scala 2.11.12 + Spark 2.4.3**，因此建议使用对应版本的 JDK 和依赖环境。 +> 项目以 **Spark 2.4.3 + Scala 2.11 + JDK 8** 为基准，运行环境不要随意升级 JVM / Scala 版本。 --- ## 项目结构 ```text -spark_20260915/ +spark_project/ ├── pom.xml -├── README.md ├── AGENTS.md +├── README.md │ -├── src/ -│ ├── main/ -│ │ ├── java/ -│ │ │ └── org/example/ -│ │ │ └── core/ -│ │ │ ├── GroupByKeyDemo.java -│ │ │ ├── MyPartitioner.java -│ │ │ ├── RddCreateDemo.java -│ │ │ └── RepartitionVsCoalesce.java -│ │ │ -│ │ ├── scala/ -│ │ │ └── org/ -│ │ │ ├── example/ -│ │ │ │ ├── App.scala -│ │ │ │ ├── test.scala -│ │ │ │ ├── core/ -│ │ │ │ └── sql/ -│ │ │ │ -│ │ │ └── exercises/ -│ │ │ ├── exercises1/ -│ │ │ ├── exercises2/ -│ │ │ ├── exercises3/ -│ │ │ ├── exercises4/ -│ │ │ └── exercises5/ -│ │ │ -│ │ └── resources/ -│ │ ├── log4j.properties -│ │ ├── word.txt -│ │ └── create_table.sql -│ │ -│ └── test/ -│ └── java/ +├── src/main/java/org/example/ +│ ├── core/ +│ │ ├── GroupByKeyDemo.java +│ │ ├── MyPartitioner.java +│ │ ├── RddCreateDemo.java +│ │ └── RepartitionVsCoalesce.java +│ └── AppTest.java │ -└── target/ +├── src/main/scala/org/example/ +│ ├── App.scala +│ ├── test.scala +│ └── core/ +│ ├── GroupByKeyDemo.scala +│ ├── MyPartitioner.scala +│ ├── RddCreateDemo.scala +│ └── RepartitionVsCoalesce.scala +│ +├── src/main/scala/org/exercises/ +│ ├── exercises1/ +│ ├── exercises2/ +│ ├── exercises3/ +│ └── ... +│ +└── src/main/resources/ + ├── create_table.sql + ├── log4j.properties + └── word.txt ``` -### 目录说明 - -#### `org/example` - -主要存放课程外的 Demo、线下课程代码以及一些完整示例。 - -其中： - -```text -org/example/core/ -``` - -主要用于演示 Spark Core 基础功能，包括： - -- RDD 创建 -- `groupByKey` -- 自定义 `Partitioner` -- `repartition` -- `coalesce` - -同时存在 Java 与 Scala 两套实现，用于对比两种语言编写 Spark 程序的方式。 - -```text -org/example/sql/ -``` - -用于存放 Spark SQL / DataFrame 相关示例，例如通过 `SparkSession` 创建 DataFrame。 - --- -#### `org/exercises` +## Spark 学习进度 -这是本项目最核心的学习目录。 +### 第 1 课：Spark 入门 -每一课按照课程编号划分： +主要内容： -```text -exercises1 -exercises2 -exercises3 -exercises4 -exercises5 -``` +- `SparkConf` +- `SparkContext` +- `parallelize` +- 从文件创建 RDD +- Spark 程序基本运行方式 +- Transformation / Action 基本概念 -通常将： - -```text -demo/ -``` - -用于课程演示代码， - -```text -exercises/ -``` - -用于自己完成的课后练习。 - -这样可以把“看懂 Demo”和“自己写代码”区分开。 - ---- - -# 课程进度 - -## 第 1 课：Spark 是什么，以及第一个 Spark 程序 - -目录： +对应练习： ```text src/main/scala/org/exercises/exercises1/ ``` -主要学习： - -- Spark 的基本概念 -- `SparkConf` -- `SparkContext` -- 本地模式 `local` -- 从集合创建 RDD -- 从文件创建 RDD -- Transformation -- Action -- 第一个 WordCount - -这一课的目标是先建立 Spark 程序的整体结构。 - --- -## 第 2 课：RDD 常用算子 +### 第 2 课：RDD 常用算子 -目录： +主要学习： + +- `map` +- `filter` +- `flatMap` +- `reduce` +- `foreach` + +重点理解： + +```text +Transformation + ↓ +生成新的 RDD + ↓ +继续构建计算链 + +Action + ↓ +触发 Job 执行 + ↓ +返回结果 / 输出结果 +``` + +对应练习： ```text src/main/scala/org/exercises/exercises2/ ``` -重点学习单值 RDD 的常见操作： - -| 练习 | 内容 | -| --- | --- | -| Ex 1 | `map` | -| Ex 2 | `filter` | -| Ex 3 | `flatMap` | -| Ex 4 | `reduce` | -| Ex 5 | `foreach` | - -通过这些练习理解： - -```text -RDD - ↓ -Transformation - ↓ -Action -``` - -并逐渐熟悉 Scala 函数、匿名函数以及 Spark 算子的使用方式。 - --- -## 第 3 课：PairRDD 与 reduceByKey +### 第 3 课：PairRDD / WordCount -目录： +主要学习： -```text -src/main/scala/org/exercises/exercises3/ -``` - -重点学习： - -- `(K, V)` 类型的 PairRDD -- `map` +- `(K, V)` 键值对 RDD +- `map` 生成 PairRDD - `reduceByKey` - WordCount - -核心代码结构： - -```scala -rdd - .flatMap(...) - .map(...) - .reduceByKey(...) - .collect() -``` - -这一课开始正式进入 Spark 中非常重要的 **Key-Value 数据处理模式**。 - ---- - -## 第 4 课：groupByKey、reduceByKey 与 Shuffle - -目录： - -```text -src/main/scala/org/exercises/exercises4/ -``` - -重点学习： - - `groupByKey` -- `reduceByKey` -- Shuffle -- Map 端局部聚合 -- 宽依赖与窄依赖 -- 为什么 `reduceByKey` 通常比直接 `groupByKey` 更适合做聚合计算 - -通过实际 Demo 对比： - -```text -groupByKey -``` - -和： - -```text -reduceByKey -``` - -的数据处理过程，理解 Shuffle 在 Spark 中到底发生了什么。 - ---- - -## 第 5 课：Partition 分区 - -目录： - -```text -src/main/scala/org/exercises/exercises5/ -``` - -主要学习 Spark RDD 的分区机制。 - -重点内容： - -- `getNumPartitions` -- `glom` -- RDD 分区查看 -- `repartition` -- `coalesce` -- `partitionBy` -- 自定义 `Partitioner` -- Key 到 Partition 的映射 - -例如自定义分区器： - -```scala -class MyPartitioner extends Partitioner { - - override def numPartitions: Int = 2 - - override def getPartition(key: Any): Int = { - key.asInstanceOf[Int] % 2 - } -} -``` - -通过代码理解： - -```text -RDD - ↓ -Partition - ↓ -Task -``` - -以及 Key 如何决定数据最终进入哪个 Partition。 - -当前仓库 `main` 分支最新提交已经进入这一课。 - ---- - -# 线下课程 Demo - -除了 ChatGPT 分课练习之外，仓库还保留了一些线下课程代码，用于补充 Spark 实际开发中的知识。 - -## RDD 创建、操作与重分区 - -主要涉及： - -- RDD 创建 -- RDD Transformation -- RDD Action -- `repartition` -- `coalesce` -- Partition - ---- - -## Cache / Persist / Checkpoint - -用于理解 Spark 中的数据持久化机制，包括： - -- `cache()` -- `persist()` -- `checkpoint()` -- Checkpoint 目录 -- RDD 血缘关系 -- 长依赖链优化 - -同时包含 Spark 程序打包以及向 YARN 提交运行的相关学习内容。 - ---- - -## Spark SQL / DataFrame - -目录： - -```text -src/main/scala/org/example/sql/ -``` - -当前已有 DataFrame 创建示例，通过： - -```scala -SparkSession -``` - -创建 Spark 应用，然后： - -```scala -import spark.implicits._ - -val df = data.toDF() - -df.show() -df.printSchema() -``` - -用于学习： - -- `SparkSession` -- DataFrame -- `toDF` -- `show` -- `printSchema` - -当前仓库已经包含对应的 DataFrame Demo。 - ---- - -# WordCount - -项目中多处使用 WordCount 作为学习案例。 +- shuffle 的基本概念 典型流程： @@ -408,346 +157,455 @@ df.printSchema() ↓ flatMap ↓ -拆分单词 - ↓ map ↓ -(word, 1) - ↓ reduceByKey ↓ -统计单词数量 +collect ``` -Scala 示例： - -```scala -val result = textFile - .flatMap(_.split(" ")) - .map(word => (word, 1)) - .reduceByKey(_ + _) -``` - -WordCount 看起来简单，但可以贯穿整个 Spark 学习过程： +对应练习： ```text -RDD - ↓ -Transformation - ↓ -PairRDD - ↓ -reduceByKey - ↓ -Shuffle - ↓ -Partition +src/main/scala/org/exercises/exercises3/ ``` -因此本项目会反复使用 WordCount 来帮助理解 Spark 的底层处理过程。 - --- -# Maven 构建 +### 第 4～5 课：Scala 函数基础 + Spark 分区 -## 拉取依赖 +Scala 部分重点： + +- `def` +- `=>` +- `map` +- 函数作为参数 +- `_` 下划线简写 +- Lambda / 函数值 +- 函数参数与返回值 + +Spark 部分重点： + +- Partition +- `getNumPartitions` +- `glom` +- `mapPartitions` +- `partitionBy` +- 自定义 `Partitioner` +- `groupByKey` +- `reduceByKey` +- `repartition` +- `coalesce` + +项目中的核心 Demo： + +```text +src/main/scala/org/example/core/ +src/main/java/org/example/core/ +``` + +--- + +### 第 6～7 课：RDD 执行过程与缓存 + +主要内容： + +- Transformation 与 Action +- Lazy Evaluation +- DAG +- Job / Stage / Task +- Cache +- Persist +- `mapPartitions` +- 多次 Action 时为什么缓存可能提升性能 +- Spark UI 中查看 Job / Stage / Task + +重点认识： + +```text +Transformation + ↓ +只记录计算逻辑 + ↓ +Action + ↓ +真正触发 Job +``` + +以及： + +```text +RDD + ├── cache() + └── persist(...) +``` + +缓存不是“加了就一定更快”，只有同一个 RDD 被重复使用、重新计算成本较高时，收益才比较明显。 + +--- + +### 第 8 课：flatMap 与嵌套集合 + +主要学习： + +- `map` 与 `flatMap` 的区别 +- 嵌套集合处理 +- 一对多转换 +- WordCount 中为什么常用 `flatMap` +- 不使用 `flatMap` 的替代实现 + +典型理解： + +```text +map +1 -> List(1, 2) +2 -> List(3, 4) + +结果： +List(List(1, 2), List(3, 4)) +``` + +```text +flatMap +1 -> List(1, 2) +2 -> List(3, 4) + +结果： +List(1, 2, 3, 4) +``` + +--- + +### 第 9 课：排序与分组 + +主要学习： + +- `sortBy` +- `sortWith` +- `groupBy` +- 分组后 `Iterable / CompactBuffer` 的理解 +- 排序与分组的使用场景 +- PairRDD 与普通 RDD 的进一步操作 + +常见写法： + +```scala +rdd.sortBy(_._2) +rdd.sortWith((a, b) => a._2 > b._2) +rdd.groupBy(_ % 2) +``` + +--- + +## 当前已掌握的 RDD 知识体系 + +```text +Spark +│ +├── SparkConf / SparkContext +│ +├── RDD +│ ├── 创建 +│ │ ├── parallelize +│ │ └── textFile +│ │ +│ ├── Transformation +│ │ ├── map +│ │ ├── filter +│ │ ├── flatMap +│ │ ├── mapPartitions +│ │ ├── groupBy +│ │ ├── sortBy +│ │ ├── sortWith +│ │ └── reduceByKey +│ │ +│ ├── Action +│ │ ├── collect +│ │ ├── count +│ │ ├── reduce +│ │ └── foreach +│ │ +│ ├── Partition +│ │ ├── glom +│ │ ├── getNumPartitions +│ │ ├── partitionBy +│ │ ├── repartition +│ │ └── coalesce +│ │ +│ └── 性能 +│ ├── cache +│ ├── persist +│ └── Lazy Evaluation +│ +└── PairRDD + ├── reduceByKey + ├── groupByKey + └── 自定义 Partitioner +``` + +--- + +## Spark SQL / DataFrame / Hive + +RDD 基础阶段完成后，项目继续进入 Spark SQL 相关内容： + +- `SparkSession` +- DataFrame +- DataSet 基础概念 +- Schema +- DSL 查询 +- SQL 查询 +- JDBC +- Hive 支持 +- Spark Thrift Server +- DBeaver 连接 Spark SQL +- DataFrame 与 JDBC 数据写入 + +目前已经开始接触： + +```scala +val spark = SparkSession.builder() + .appName("Spark On Hive") + .enableHiveSupport() + .getOrCreate() +``` + +以及： + +```scala +spark.sql("show databases") +spark.sql("show tables") +spark.sql("select ...") +``` + +后续会把 RDD 学到的思想逐步对应到 DataFrame / SQL 中。 + +--- + +## Spark 集群实践 + +除了本地 `local` 模式，还会进行 Spark 集群环境实验。 + +已经实践过的内容包括： + +- `spark-submit` +- Yarn Client +- HDFS +- Spark UI +- Spark History Server +- Hive / Hive Metastore +- Spark Thrift Server +- Beeline +- DBeaver +- Spark SQL + +例如： + +```bash +spark-submit \ + --master yarn \ + --deploy-mode client \ + --class org.example.core.App2 \ + spark_project-1.0-SNAPSHOT.jar +``` + +--- + +## 快速开始 + +### 1. 准备环境 + +确保本机具备： + +```text +JDK 8 +Scala 2.11.x +Maven 3.x +``` + +### 2. 编译 ```bash mvn -DskipTests dependency:resolve -``` -## 编译 - -```bash mvn compile ``` -## 测试 - -```bash -mvn test -``` - -目前测试目录主要用于预留，随着课程推进逐步补充测试。 - -## 打包 +### 3. 打包 ```bash mvn package ``` -完成后会生成： +生成： ```text target/spark_project-1.0-SNAPSHOT-jar-with-dependencies.jar ``` -项目目前使用 `scala-maven-plugin` 编译 Scala，并使用 `maven-assembly-plugin` 打包包含依赖的 Fat JAR。 +### 4. IDEA 运行 + +在 IntelliJ IDEA 中直接运行 Scala / Java 中的 `object` 或 `main` 方法即可。 --- -# 运行程序 +## 本地 Spark UI -## IntelliJ IDEA - -推荐直接在 IntelliJ IDEA 中运行。 - -打开： +本地运行 Spark 程序时，可以通过 Spark Web UI 查看： ```text -pom.xml +http://localhost:4040 ``` -等待 Maven 加载完成后，可以直接找到带有： - -```scala -def main(args: Array[String]): Unit -``` - -的 Scala `object` 运行。 - -例如： +常见页面： ```text -org.example.App +Jobs +Stages +Storage +Environment +Executors +SQL ``` -或者： +注意： -```text -org.exercises.exercises5.demo.Demo -``` - -具体运行哪个类，根据当前学习章节选择即可。 +- `4040` 是当前 Spark Application 的 Web UI 端口 +- Application 结束后，4040 通常就不再提供该 Application 的实时页面 +- `18080` 是 Spark History Server，不是本地运行 Application 的实时 UI --- -## 命令行运行 Fat JAR +## MySQL / JDBC -例如： +`src/main/resources/create_table.sql` 中保留了后续分析结果的目标表。 -```bash -java -cp target/spark_project-1.0-SNAPSHOT-jar-with-dependencies.jar org.example.App +目前主要规划： + +```text +Spark DataFrame + ↓ + 聚合分析 + ↓ + JDBC 写入 + ↓ + MySQL ``` -项目主要用于本地学习和实验，不要求先搭建真正的 Spark 集群。 +目标表： + +| 表名 | 用途 | +| --- | --- | +| `top_ten_avg_ratings` | Top10 平均评分电影 | +| `genres_average_rating` | 类型平均评分 | + +相关依赖： + +```text +mysql-connector-java +HikariCP +commons-dbutils +``` --- -# 学习方式 +## 代码规范 -本项目建议按照下面的方式学习： +### Demo 命名 + +按课程 / 知识点拆分 Demo，尽量保持： ```text -先看 Demo - ↓ -理解代码 - ↓ -自己完成 Exercises - ↓ -运行并观察结果 - ↓ -修改代码验证结论 - ↓ -记录到 Git +Demo1xxx +Demo2xxx +... ``` -尤其是学习 Spark 时，不建议只看最终输出。 +### Commit -例如学习 Partition 时，可以通过： - -```scala -rdd.getNumPartitions -rdd.glom().collect() -``` - -直接观察不同 Partition 中的数据。 - -学习 Shuffle 时，则重点观察： +推荐： ```text -数据在不同 Partition 之间如何重新分布 +feat:线下课：集合_... +feat:ChatGPT第 7 课：缓存 Cache / Persist + mapPartitions +fix:修复 ... +docs:更新 README +refactor:重构 ... ``` -这样比单纯记住 API 更容易真正理解 Spark。 +每个知识点尽量保持一个独立 commit，便于后续按课程回看。 --- -# Git 提交规范 +## 学习目标 -当前项目采用简洁的中文 Commit Message。 - -推荐格式： +最终形成一套完整的 Spark 学习路线： ```text -feat:ChatGPT 第 X 课：课程主题 -``` - -例如： - -```text -feat:ChatGPT 第 1 课：Spark 是什么，以及第一个 Spark 程序 -feat:ChatGPT 第 2 课：RDD 常用算子 -feat:ChatGPT 第 3 课：PairRDD 与 reduceByKey -feat:ChatGPT 第 4 课：groupByKey、reduceByKey 与 Shuffle -feat:ChatGPT 第 5 课：Partition 分区 -``` - -其他类型： - -```text -docs:README -build:更新 Maven 依赖 -``` - -建议一节课一个主要 Commit，一道独立练习尽量保持原子提交。 - ---- - -# 开发约定 - -### Java / Scala - -项目同时保留 Java 和 Scala 两套实现。 - -学习阶段以 Scala 为主，Java Demo 主要用于： - -- 对照 Spark API -- 理解 Java 与 Scala 的写法差异 -- 复习 Spark 基础 API - -新课程练习优先使用 Scala。 - -### Spark 模式 - -学习阶段主要使用： - -```scala -.setMaster("local") -``` - -或者： - -```scala -.setMaster("local[2]") -``` - -部分 DataFrame Demo 使用本地多线程模式。 - -整个项目定位是： - -> **本地 Spark 学习、实验与知识整理仓库** - -而不是生产环境 Spark 项目。 - ---- - -# MySQL / JDBC 扩展 - -项目 Maven 依赖中已经包含： - -- MySQL Connector -- HikariCP -- commons-dbutils - -资源目录中也保留： - -```text -src/main/resources/create_table.sql -``` - -用于后续 Spark 数据处理结果写入 MySQL 的实验。 - -后续可以继续完善： - -```text -Spark - ↓ -RDD / DataFrame - ↓ -数据分析 - ↓ +Scala 基础 + ↓ +RDD 基础 + ↓ +PairRDD + ↓ +Partition / Shuffle + ↓ +Cache / DAG / Stage / Task + ↓ +Spark SQL / DataFrame + ↓ +Hive + ↓ JDBC - ↓ -MySQL + ↓ +Spark Thrift Server + ↓ +Yarn / 集群运行 + ↓ +完整数据分析项目 ``` -逐步从 Spark 基础练习过渡到实际的数据处理流程。 - ---- - -# 当前学习进度 +重点不是只记 API，而是逐步理解： ```text -✅ 第 1 课：Spark 入门 -✅ 第 2 课：RDD 常用算子 -✅ 第 3 课：PairRDD 与 reduceByKey -✅ 第 4 课：groupByKey、reduceByKey 与 Shuffle -✅ 第 5 课：Partition 分区 - -✅ 线下课：RDD 创建 / 操作 / 重分区 -✅ 线下课：Cache / Persist / Checkpoint -✅ 线下课：Spark 程序打包 / YARN -✅ 线下课：创建 DataFrame - -⬜ 后续课程：继续学习 Spark Core -⬜ 后续课程：Spark SQL / DataFrame 深入 -⬜ 后续课程：真实数据分析案例 +代码怎么写 + ↓ +RDD 怎么产生 + ↓ +Transformation 怎么串起来 + ↓ +Action 什么时候触发 + ↓ +Spark 如何拆成 Job / Stage / Task + ↓ +数据如何在 Partition 之间流动 + ↓ +Shuffle 为什么发生 + ↓ +为什么某些写法性能更好 ``` --- -# 后续规划 +## 学习记录 -后续按照课程继续补充： - -```text -Spark Core - ↓ -RDD - ↓ -Shuffle - ↓ -Partition - ↓ -持久化 - ↓ -广播变量 / 累加器 - ↓ -Spark SQL - ↓ -DataFrame - ↓ -数据分析案例 - ↓ -MySQL / JDBC -``` - -项目会尽量保持： - -- 一课一目录 -- Demo 与 Exercises 分离 -- 代码可以直接运行 -- 中文注释辅助理解 -- 每个知识点配合实际输出验证 -- 用 Git 记录学习进度 +| 阶段 | 内容 | 状态 | +| --- | --- | --- | +| 01 | Spark 入门 | ✅ | +| 02 | RDD 常用算子 | ✅ | +| 03 | PairRDD / WordCount | ✅ | +| 04 | Scala 函数基础 | ✅ | +| 05 | 函数作为参数 / Partition | ✅ | +| 06 | RDD 执行与惰性计算 | ✅ | +| 07 | Cache / Persist / mapPartitions | ✅ | +| 08 | flatMap / 嵌套集合 | ✅ | +| 09 | sortBy / sortWith / groupBy | ✅ | +| 10+ | Spark SQL / DataFrame / Hive | 🚧 | --- -## 项目定位 +## 相关资源 -这是一个以 **“边学、边写、边运行、边总结”** 为核心的 Spark 学习仓库。 - -相比只保存课堂代码，本项目更关注： - -```text -为什么这么写 -↓ -代码实际做了什么 -↓ -Spark 底层发生了什么 -↓ -运行结果为什么是这样 -``` - -通过持续增加 Demo 和练习，将 Spark 的知识点逐渐串联起来，形成一套完整的个人学习笔记与实践代码库。 \ No newline at end of file +- Apache Spark： +- Apache Hadoop： +- Apache Maven：