Hadoop+Spark+Hive+Django农作物产量可视化分析系统

做大数据方向的毕业设计，最容易踩的坑不是代码写不出来，而是环境跑不起来、数据流走不通、答辩时说不清楚每个组件到底干了什么。Hadoop + Spark + Hive + Django 这套组合看起来是"老四样"，但真要把一条从原始 CSV 到可视化大屏的链路完整跑通，中间涉及 HDFS 存储、Hive 数仓分层、Spark 离线计算、Django 接口封装和前端图表渲染五个环节，任何一个环节配置错一个端口或者版本对不上，整条链路就断在那里。

这次我们看的是一套基于 Django 的农作物产量趋势可视化分析系统，技术栈是 Hadoop 做分布式存储、Hive 做数据仓库分层建模、Spark 做离线指标计算、Django 提供后端接口、前端用 ECharts 出图。它解决的核心问题很明确：把分散的、格式不统一的农作物产量统计数据，变成可以按年份、按地区、按作物品种多维下钻的趋势图表，并且整个过程是可复现的批处理流程，而不是手工在 Excel 里拉透视表。

这篇文章不讲空泛的"大数据赋能农业"，而是按实际落地顺序拆开写：环境怎么准备、集群怎么起、Hive 表怎么建、Spark 任务怎么写和怎么提交、Django 接口怎么对接、页面怎么验证、内存和任务耗时怎么观察、出错怎么排查。适合正在做大数据毕设、需要一套可运行可答辩的完整链路的读者，也适合想把离线数仓流程走一遍的后端和数据分析方向的同学。

1. 项目核心能力速览

先把关键信息摆出来，方便判断这套东西适不适合你的场景。下面表格里的参数，凡是没有明确材料支撑的，都写成"需按实际环境测试"，不做硬性承诺。

需要提前说清楚一点：这套架构的重点不是"技术名词多"，而是每个组件职责清晰、数据流向可追踪。答辩时被问到"Hive 和 Spark 分别干什么"，你得能一句话答上来——Hive 管元数据和 SQL 查询入口，Spark 管真正的分布式计算，Django 只是把算好的结果读出来渲染。

2. 适用场景与选题边界

这套系统的定位非常具体。它适合需要展示"完整大数据链路"的毕设选题，因为从数据采集、存储、建模、计算到展示，五个环节都有实物产出，答辩时既有代码也有页面，不至于只讲 PPT。

从使用者角度看，它主要解决三类问题。第一类是数据整合问题：农作物产量数据往往来自不同年份的统计材料，字段命名不一致、单位不统一、存在缺失值和异常值，需要一套清洗规则沉淀下来。第二类是多维分析问题：同一份数据要支持按年份看趋势、按地区看排名、按作物看结构占比，用 Excel 做一次两次还行，做成系统就需要预计算和索引。第三类是展示问题：趋势图、堆叠柱状图、地图、饼图这些图表要能和筛选条件联动，而不是静态截图。

不适合的场景也要讲明白。如果数据量只有几千行，用 Pandas 加 Flask 就够了，硬上 Hadoop 反而增加部署成本；如果要求秒级响应的实时看板，这套离线链路不满足；如果要做预测模型（比如时间序列预测下一年产量），那是另一个模块，需要额外引入 Spark MLlib 或独立模型服务，本文的链路只覆盖描述性统计分析。

合规方面必须提一句：涉及真实农业统计数据时，请使用公开统计年鉴或已获授权的数据源，注意数据引用规范；如果数据中包含农户个人信息、地块位置等敏感字段，必须做脱敏处理，不要上传到公开代码仓库。毕设项目中常见的错误是把原始数据直接提交到 GitHub，这一点务必避免。

3. 技术架构与数据流转设计

把链路画清楚比写代码更重要。这套系统的数据流大致是五段：

1. 原始数据文件放到本地目录，或者直接上传到 HDFS 指定路径。
2. Hive 建立原始层（ODS）表，通过外部表指向 HDFS 上的原始文件，保留原始字段不做修改。
3. Hive 建立明细层（DWD）和汇总层（DWS/ADS）表，用 SQL 完成清洗、标准化、聚合。
4. Spark 读取 Hive 表或 HDFS 文件，执行较重的计算逻辑（同比环比、增长率、多维度聚合），结果写回 Hive 结果表或导出为 Parquet/CSV。
5. Django 通过数据库连接或直接读取结果文件，封装成 JSON 接口，前端 ECharts 拉取数据渲染。

数仓分层建议保持简单，毕设不需要搞得太复杂，三层足够：

这种"一表一图"的设计在毕设里非常实用，因为前端每个图表只需要一个接口，接口只需要查一张表，逻辑清晰，出问题也好定位。

4. 环境准备与集群前置条件

4.1 硬件与操作系统

伪分布式部署对硬件要求不高，一般 8G 内存以上、50G 以上可用磁盘就能跑起来，但要注意 Hadoop、Hive、Spark 三个 JVM 进程同时驻留会吃掉不少内存。如果本机只有 8G 内存，建议把 YARN 容器内存调小，或者用 Spark local 模式跑计算、Hadoop 只用来存文件。

操作系统建议 Linux（Ubuntu 20.04/22.04 或 CentOS 7 系列），Windows 上跑 Hadoop 需要额外处理 winutils，问题较多，不推荐作为主环境。如果必须在 Windows 上开发，可以把 Django 和前端放在 Windows，Hadoop/Hive/Spark 放在虚拟机或服务器上，通过 IP 访问。

必备前置条件清单：

• JDK 8 或 JDK 11（Hadoop 3.x 与 Spark 3.x 常用组合，具体以所装版本官方要求为准）
• SSH 免密登录（伪分布式也需要，否则启动脚本会卡在密码输入）
• 主机名与 hosts 映射配置正确
• 防火墙端口放行或直接关闭测试环境的防火墙
• Python 3.8 及以上（Django 与 PySpark 依赖）

4.2 依赖版本与目录规划

版本选择上，最稳妥的原则是"同一生态内版本对齐"，不要混用跨度太大的版本。下面给一套常见组合作为参考，实际安装时以官方文档为准：

目录规划建议统一放在一个工作根目录下，避免路径混乱：

bash复制# 建议的目录结构示例，路径按实际情况调整
/opt/bigdata/
├── hadoop/
├── hive/
├── spark/
├── data/            # 原始数据文件
│   ├── raw/
│   └── output/
└── project/
    ├── crop_analysis/   # Django 项目
    └── spark_jobs/      # Spark 作业脚本

4.3 端口与环境变量检查

启动前先确认关键端口没有被占用。HDFS 常见端口是 9870（Web UI）和 8020（RPC），YARN 是 8088，Hive 的 metastore 默认 9083，Django 开发服务器常用 8000。检查方式：

bash复制# 查看端口占用情况
ss -lntp | grep -E '9870|8020|8088|9083|8000'

# 或者用 netstat
netstat -tunlp | grep 9870

环境变量写在 ~/.bashrc 里，注意 HADOOP_HOME、HIVE_HOME、SPARK_HOME 三个都要配，PATH 里加上各自的 bin 目录。Hive 还需要额外注意 HIVE_CONF_DIR，Spark 读取 Hive 表时需要 hive-site.xml 能被找到。

5. Hadoop 与 Hive 环境搭建启动

5.1 HDFS 格式化与集群启动

伪分布式模式下，先配置 core-site.xml 和 hdfs-site.xml，指定 fs.defaultFS 和副本数（伪分布式副本数设为 1）。首次使用需要格式化 NameNode，注意这一步只能执行一次，重复执行会导致数据目录被清空：

bash复制# 首次初始化，已格式化过不要重复执行
hdfs namenode -format

# 启动 HDFS
start-dfs.sh

# 启动 YARN（如果 Spark 用 on yarn 模式）
start-yarn.sh

# 验证进程
jps

jps 能看到 NameNode、DataNode、SecondaryNameNode 说明 HDFS 起来了；如果 YARN 也启动，还会看到 ResourceManager 和 NodeManager。少进程是最常见的启动失败表现，直接去看 logs 目录下对应的 .log 文件，一般是配置文件路径写错或者 Java 版本不兼容。

创建业务目录并上传原始数据：

bash复制# 创建 HDFS 目录
hdfs dfs -mkdir -p /crop/data/raw
hdfs dfs -mkdir -p /crop/data/warehouse

# 上传本地数据文件
hdfs dfs -put /opt/bigdata/data/raw/crop_yield.csv /crop/data/raw/

# 确认上传成功
hdfs dfs -ls /crop/data/raw/

5.2 Hive 元数据配置与建表

Hive 默认用 Derby 做元数据库，只支持单会话，多个窗口同时连会报锁错误。毕设项目建议直接换成 MySQL，一次性解决。配置集中在 hive-site.xml：

xml复制<!-- hive-site.xml 关键配置示例，按实际环境替换 -->
<configuration>
    <property>
        <name>javax.jdo.option.ConnectionURL</name>
        <value>jdbc:mysql://localhost:3306/hive_meta?createDatabaseIfNotExist=true&amp;useSSL=false</value>
    </property>
    <property>
        <name>javax.jdo.option.ConnectionDriverName</name>
        <value>com.mysql.cj.jdbc.Driver</value>
    </property>
    <property>
        <name>javax.jdo.option.ConnectionUserName</name>
        <value>hive</value>
    </property>
    <property>
        <name>javax.jdo.option.ConnectionPassword</name>
        <value>your_password</value>
    </property>
    <property>
        <name>hive.metastore.uris</name>
        <value>thrift://localhost:9083</value>
    </property>
</configuration>

MySQL 驱动 jar 要放到 Hive 的 lib 目录下，这一步漏了会报 ClassNotFoundException。初始化元数据库：

bash复制# 初始化 schema，Hive 3.x 使用 schematool
schematool -dbType mysql -initSchema

# 启动 metastore 服务（后台）
hive --service metastore &

# 进入 Hive 命令行
hive

建表环节，ODS 层用外部表指向 HDFS 文件，这样删表不会删数据，方便反复调试：

sql复制-- ODS 原始层：外部表，字段全用 string 承接，避免脏数据导入失败
CREATE EXTERNAL TABLE IF NOT EXISTS ods_crop_yield_raw (
    stat_year      STRING COMMENT '统计年份',
    region_name    STRING COMMENT '地区名称',
    crop_name      STRING COMMENT '作物名称',
    sown_area      STRING COMMENT '播种面积',
    yield_amount   STRING COMMENT '产量',
    unit_name      STRING COMMENT '计量单位'
)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ','
STORED AS TEXTFILE
LOCATION '/crop/data/raw/'
TBLPROPERTIES ("skip.header.line.count"="1");

-- DWD 明细层：字段标准化 + 类型转换 + 异常过滤
CREATE TABLE IF NOT EXISTS dwd_crop_yield_detail (
    stat_year      INT,
    region_name    STRING,
    crop_name      STRING,
    sown_area      DOUBLE,
    yield_amount   DOUBLE,
    unit_name      STRING
)
STORED AS PARQUET;

INSERT OVERWRITE TABLE dwd_crop_yield_detail
SELECT
    CAST(TRIM(stat_year) AS INT)          AS stat_year,
    TRIM(region_name)                     AS region_name,
    TRIM(crop_name)                       AS crop_name,
    CAST(TRIM(sown_area) AS DOUBLE)       AS sown_area,
    CAST(TRIM(yield_amount) AS DOUBLE)    AS yield_amount,
    TRIM(unit_name)                       AS unit_name
FROM ods_crop_yield_raw
WHERE stat_year IS NOT NULL
  AND TRIM(stat_year) REGEXP '^[0-9]{4}$'
  AND yield_amount IS NOT NULL
  AND CAST(TRIM(yield_amount) AS DOUBLE) > 0;

这里有个实操细节：ODS 层全部用 STRING 是非常有必要的，因为原始 CSV 里经常混入逗号、空格、千分位符号，直接定义成 DOUBLE 会导致整批加载失败。清洗逻辑放在 DWD 层，失败的行被 WHERE 过滤掉，同时可以另建一张异常表把这些行捞出来做数据质量报告，答辩时这也是个加分点。

6. Spark 离线计算与指标开发

6.1 计算任务设计思路

Spark 在这套系统里承担的是"重活"：跨年份聚合、同比环比计算、地区排名、品种结构占比。这些用 Hive SQL 也能做，但 Spark 在迭代计算和复杂窗口函数上更灵活，而且作业可以参数化，方便按年份批量跑。

ADS 层结果表设计成三个，对应三张核心图表：

6.2 PySpark 计算脚本示例

下面给一段趋势指标计算的脚本框架，逻辑是读取 DWD 明细表，按年份聚合，用窗口函数算同比。这段代码是通用模板，实际字段名和表名需要按你的数仓设计调整：

python复制# spark_jobs/yield_trend_job.py
from pyspark.sql import SparkSession
from pyspark.sql import functions as F
from pyspark.sql.window import Window

def build_spark(app_name="crop_yield_trend"):
    return (SparkSession.builder
            .appName(app_name)
            .config("spark.sql.warehouse.dir", "/crop/data/warehouse")
            .enableHiveSupport()
            .getOrCreate())

def main():
    spark = build_spark()

    # 读取明细层数据
    df = spark.sql("SELECT stat_year, region_name, crop_name, sown_area, yield_amount "
                   "FROM dwd_crop_yield_detail WHERE stat_year IS NOT NULL")

    # 按年份聚合
    year_df = (df.groupBy("stat_year")
                 .agg(F.sum("yield_amount").alias("total_yield"),
                      F.sum("sown_area").alias("total_area"))
                 .orderBy("stat_year"))

    # 计算同比增长率：需要先排序再取上一行
    w = Window.orderBy("stat_year")
    trend_df = (year_df
                .withColumn("prev_yield", F.lag("total_yield", 1).over(w))
                .withColumn("yoy_rate",
                            F.when(F.col("prev_yield").isNull(), None)
                             .otherwise(F.round(
                                 (F.col("total_yield") - F.col("prev_yield"))
                                 / F.col("prev_yield") * 100, 2))))

    # 写入结果表
    trend_df.select("stat_year", "total_yield", "total_area", "yoy_rate") \
            .write.mode("overwrite") \
            .format("parquet") \
            .saveAsTable("ads_yield_trend_year")

    spark.stop()

if __name__ == "__main__":
    main()

地区排名和品种占比同理，区别只在 groupBy 维度和排名窗口函数。排名可以用 F.row_number().over(Window.partitionBy("stat_year").orderBy(F.desc("total_yield")))。

6.3 作业提交与参数化

提交方式按部署形态分两种。local 模式适合本机调试，速度快、日志直观；yarn 模式更接近生产，但需要集群资源充足。

bash复制# local 模式调试
spark-submit \
  --master local[2] \
  --driver-memory 1g \
  --conf spark.sql.shuffle.partitions=8 \
  spark_jobs/yield_trend_job.py

# yarn 模式提交，参数按集群规模调整
spark-submit \
  --master yarn \
  --deploy-mode client \
  --executor-memory 2g \
  --executor-cores 2 \
  --num-executors 2 \
  --conf spark.sql.shuffle.partitions=20 \
  spark_jobs/yield_trend_job.py --year 2023

参数化很重要。把年份、地区这类过滤条件通过 sys.argv 或 argparse 传进去，配合 shell 循环就能实现按年份批量跑：

bash复制#!/bin/bash
# run_all_years.sh：按年份批量提交，失败即退出
set -e
for year in 2019 2020 2021 2022 2023; do
    echo "开始处理年份: ${year}"
    spark-submit --master local[2] \
        spark_jobs/yield_trend_job.py --year "${year}" \
        >> logs/spark_${year}.log 2>&1
    echo "年份 ${year} 处理完成"
done

毕设答辩时，这段批量脚本比单个作业更能体现"工程化"意识。加上日志重定向和 set -e，任务失败能立刻停下，不会出现一半年份成功一半失败还继续跑的情况。

7. Django 后端与可视化接口

7.1 项目结构与数据读取

Django 这边不承担计算，只负责查询和返回 JSON。数据来源有两种方案：一是直接查 Hive（通过 impyla 或 JDBC 桥接），二是把 ADS 结果同步到 MySQL 后查 MySQL。毕设场景强烈推荐第二种，因为 Hive 查询延迟高，前端图表每次刷新都等几秒体验很差，而结果表数据量小，同步到 MySQL 后毫秒级返回。

项目结构大致如下：

bash复制crop_analysis/
├── manage.py
├── crop_analysis/          # 配置
│   ├── settings.py
│   └── urls.py
├── analysis/               # 业务应用
│   ├── models.py
│   ├── views.py
│   └── urls.py
├── static/                 # ECharts 等静态资源
└── templates/              # 页面模板

结果表同步可以用 Spark 直接写 JDBC，也可以在 Spark 作业最后追加一段 df.write.jdbc()，或者用 sqoop（如果环境里有）。最简单的做法是 Spark 作业输出 CSV，再用 Django 的 loaddata 或自定义管理命令导入 MySQL，数据量小的时候完全够用。

7.2 模型定义与接口实现

MySQL 里建三张结果表对应三个图表，Django 模型示例如下：

python复制# analysis/models.py
from django.db import models

class YieldTrendYear(models.Model):
    stat_year = models.IntegerField(primary_key=True)
    total_yield = models.FloatField()
    total_area = models.FloatField()
    yoy_rate = models.FloatField(null=True)

    class Meta:
        db_table = "ads_yield_trend_year"
        managed = False   # 表由外部创建，Django 不管建表


class YieldRegionRank(models.Model):
    id = models.AutoField(primary_key=True)
    stat_year = models.IntegerField()
    region_name = models.CharField(max_length=64)
    total_yield = models.FloatField()
    rank_no = models.IntegerField()

    class Meta:
        db_table = "ads_yield_region_rank"
        managed = False

managed = False 是一个很实用的细节，表示这些表由 Hive/Spark 侧维护，Django 只读，避免 migrate 时误建表覆盖。

接口部分用函数视图或 DRF 都可以，毕设用函数视图更直观：

python复制# analysis/views.py
from django.http import JsonResponse
from .models import YieldTrendYear, YieldRegionRank

def api_yield_trend(request):
    rows = YieldTrendYear.objects.all().order_by("stat_year")
    data = [{
        "year": r.stat_year,
        "yield": r.total_yield,
        "area": r.total_area,
        "yoy": r.yoy_rate,
    } for r in rows]
    return JsonResponse({"code": 0, "data": data})


def api_region_rank(request):
    year = request.GET.get("year")
    qs = YieldRegionRank.objects.all()
    if year:
        qs = qs.filter(stat_year=year)
    rows = qs.order_by("rank_no")[:10]
    data = [{"region": r.region_name, "yield": r.total_yield, "rank": r.rank_no} for r in rows]
    return JsonResponse({"code": 0, "data": data})

路由配置好后，前端就可以通过这些接口拿数据。启动开发服务器：

bash复制# 安装依赖
pip install django pymysql

# 生成并执行迁移（只针对业务自有表）
python manage.py makemigrations
python manage.py migrate

# 启动服务，默认 8000 端口
python manage.py runserver 0.0.0.0:8000

注意数据库驱动，Django 4.x 推荐用 mysqlclient，如果编译环境有问题可以退到 pymysql 并在 __init__.py 里做 install_as_MySQLdb() 替换。

7.3 前端图表联动

ECharts 部分不需要写太复杂，关键是三个图共用一个年份筛选器。页面加载时并行请求三个接口，切换年份时只重新请求地区排名和品种占比，趋势图保持不变。这样既能体现交互，又不会每次全量刷新。

javascript复制// 前端请求示例，实际放在页面 script 中
async function loadRegionRank(year) {
  const resp = await fetch(`/api/region/rank?year=${year}`);
  const json = await resp.json();
  const names = json.data.map(item => item.region);
  const values = json.data.map(item => item.yield);
  chartRegion.setOption({
    xAxis: { data: names },
    series: [{ data: values }]
  });
}

8. 功能测试与效果验证

8.1 数据导入与数仓校验

第一步先验证数据有没有完整进到 Hive。用行数比对是最直接的方法：

sql复制-- 统计各层数据量，确认清洗损耗在合理范围
SELECT COUNT(*) AS ods_cnt FROM ods_crop_yield_raw;
SELECT COUNT(*) AS dwd_cnt FROM dwd_crop_yield_detail;

-- 查看异常数据分布
SELECT stat_year, COUNT(*) FROM ods_crop_yield_raw
WHERE TRIM(stat_year) NOT REGEXP '^[0-9]{4}$'
GROUP BY stat_year;

判断标准：DWD 层行数应该等于 ODS 层减去被过滤的脏数据，两者差值过大说明清洗规则过严，差值几乎为零说明原始数据质量很好或者清洗条件没生效。这个差值比例建议记在文档里，答辩被问到数据质量时可以直接回答。

8.2 指标口径校验

同比、占比这类指标最容易算错，必须拿小样本手工核对。比如取某一年的两个地区数据，手工算一遍同比增长率，再和 ads_yield_trend_year 表里的值对比。校验点包括：分母取值是否正确、空值是否处理、单位是否统一（吨和万吨混用是常见错误）。

sql复制-- 抽样校验趋势表
SELECT stat_year, total_yield, yoy_rate
FROM ads_yield_trend_year
ORDER BY stat_year
LIMIT 10;

8.3 页面功能测试

按图表逐个验证：

• 趋势图：切换年份区间，折线是否连续，缺失年份是否断开而不是连成直线。
• 地区排名：Top10 是否按产量降序，切换年份后排名是否变化。
• 品种占比：饼图各项占比之和是否为 100%，小数位是否统一。
• 空数据场景：查询一个没有数据的年份，接口应返回空数组而不是 500 错误。

最后一条特别容易被忽略，答辩现场老师随手点一个不存在的年份，页面白屏就很尴尬。接口层面一定要做空值保护。

8.4 批量任务验证

批量脚本跑完后，检查三件事：日志中是否有 ERROR 或 Exception、结果表行数是否与预期年份数一致、重跑同一批次结果是否幂等（INSERT OVERWRITE 或 mode("overwrite") 保证这一点）。如果重跑后行数翻倍，说明写入模式写成了 append。

9. 资源占用与性能观察

这套系统的性能瓶颈通常不在磁盘，而在内存和 shuffle。观察方式有几个：

第一，Spark UI。作业运行期间打开 4040 端口（默认），能看到每个 stage 的耗时、shuffle 读写量、task 倾斜情况。如果某个 task 耗时远高于其他，说明数据分布不均，需要调整分区键。

第二，YARN 的 8088 页面。看 container 申请是否被拒、内存是否超额。如果作业卡在 ACCEPTED 状态不动，一般是队列资源不够。

第三，系统层面用 top、free -h、iostat 观察内存和磁盘 IO。Hadoop 和 Spark 同时跑的时候，JVM 堆内存配置不当很容易触发 OOM。

性能影响因素的定性判断：

显存的概念在这里不适用，这套是 CPU 计算栈，关注的是堆内存和容器内存。具体的数值必须按你的数据量和集群配置实测，不同规模差异很大，不要照搬网上的参数。

10. 常见问题与排查方法

下面这张表覆盖了这套技术栈最高频的故障，建议直接收藏对照。

排查顺序建议固定下来：先看进程和端口，再看日志，最后看数据。很多人一上来就怀疑代码写错，实际上 80% 的问题出在环境配置和服务没起来。

11. 最佳实践与答辩建议

第一，先跑通最小闭环。不要一开始就追求完整的数仓分层和漂亮的页面，先用一个几百行的 CSV 把 ODS 建表、Spark 聚合、Django 接口、前端出图这条线跑通，再逐步加数据量和维度。最小闭环一旦跑通，后面加功能就是重复劳动，心理压力小很多。

第二，数据、代码、结果分目录管理。原始数据放在 data/raw，脚本放在 spark_jobs，结果导出放 data/output，日志单独一个 logs 目录。这样出问题知道去哪找，答辩演示时目录结构本身也是加分项。

第三，所有关键参数外置。年份范围、分区数、Top10 的 N 值这些不要硬编码在代码里，用配置文件或命令行参数。答辩时被问到"换成 2024 年数据怎么办"，你能直接演示改参数重跑，比嘴上说"改一下代码就行"有说服力得多。

第四，保留一份可复现的启动脚本。把 HDFS 启动、Hive metastore 启动、Spark 提交、Django 启动写成一个 start_all.sh，哪怕只是顺序执行几条命令。换一台机器或者重装系统时，这个脚本能救你半天时间。

第五，日志和失败重试必须做。批量任务跑 5 个年份，第 3 个失败就整体退出，前面成功的也别浪费，日志里记录清楚哪年成功哪年失败。提交前做一轮完整重跑测试，确认幂等。

第六，合规和引用要写清楚。数据来源、统计口径、单位换算规则都写在 README 里；如果使用了公开统计年鉴数据，注明出处；如果数据涉及具体经营主体信息，做脱敏处理。这部分内容在论文的"数据说明"章节可以直接复用。

第七，答辩时重点讲数据流和口径。老师最常问的三个问题是：数据从哪来、清洗规则是什么、指标怎么算。把这三个问题准备成三张图或者三段话，比背技术名词有用。技术栈是手段，业务口径才是这套系统的价值所在。

12. 总结与下一步

这套 Hadoop + Spark + Hive + Django 的农作物产量分析系统，最值得动手的地方在于它把离线数仓的完整链路压缩到了一个可以在单机跑通的规模。你能亲手经历原始数据入 HDFS、Hive 建表分层、Spark 算指标、结果落库、接口输出、前端出图的全过程，每一环都有可验证的产出，而不是停留在概念层面。

最先应该验证的功能是"一条数据的完整旅程"：挑一行原始记录，跟着它从 ODS 走到 DWD，再走到 ADS，最后在页面上看到它贡献的那个数字。这条线走通了，剩下的就是复制和扩展。

最容易踩的坑集中在三处：Hive 元数据库配置（Derby 换 MySQL 那一步）、Spark 读取 Hive 表的配置文件同步、以及结果表写入模式导致的重复数据。这三个问题在上面的排查表里都有对应条目，遇到时按表查即可。

后续可以扩展的方向也很明确：把离线批处理换成 Spark Structured Streaming 做增量更新；引入 MLlib 做产量预测；把 Django 换成前后端分离架构，前端用 Vue 或 React 重写；结果查询从 MySQL 换成 ClickHouse 或 Doris 提升多维分析性能。每一条都能单独做成一个加分模块，按自己的时间和答辩要求取舍就行。