在实际计算机专业毕业设计项目中，很多同学面临的第一个难题不是写代码，而是选题和寻找一个能跑起来的、结构清晰的参考项目。一个典型的毕业设计，需要包含完整的前后端、数据库、业务逻辑和文档，但网络上找到的源码往往环境依赖复杂、代码结构混乱、缺少部署说明，导致从“下载源码”到“本地运行”之间隔着巨大的鸿沟。本文将以一个“冷链监控平台温控系统”为例，拆解如何将一个常见的毕设题目，从零开始构建成一个可运行、可演示、可扩展的完整项目。我们将聚焦于使用 Spring Boot 这一 Java 主流框架进行后端开发，并简要说明如何与 Python（数据处理）、前端（Vue/HTML）等协作，为你提供一个清晰的、可复现的毕设实现路径。

无论你的专业是计算机科学与技术、软件工程还是物联网工程，只要你的毕设涉及 Web 系统开发、数据监控或物联网应用，这篇文章都能帮你理清从环境搭建、技术选型、模块开发到最终部署演示的全流程。我们将避开空泛的理论，直接进入实战，确保你跟着步骤操作后，能获得一个具备基础温控数据采集、展示、报警功能的系统原型。

1. 理解冷链监控平台的核心需求与技术栈选型

在开始写代码之前，必须明确系统要解决什么问题。冷链监控平台的核心是确保货物（如食品、药品）在储运过程中处于规定的温度范围内。因此，系统需要实时接收来自温度传感器的数据，进行可视化展示，并在温度超标时触发报警。

一个最小可用的系统通常包含以下模块：

1. 数据采集端：模拟或真实连接温度传感器，发送数据到服务器。可以用 Python 脚本模拟数据生成，或用 Java 直接集成硬件 SDK。
2. 后端服务：接收数据、存储到数据库、处理业务逻辑（如判断是否报警）、提供 RESTful API 给前端。这是系统的核心。
3. 前端界面：展示温度实时曲线、历史数据、设备状态、报警列表等。
4. 数据库：持久化存储设备信息、温度数据、报警记录、用户信息等。

技术栈选型建议（基于“Java 毕设”热搜）：

• 后端：Spring Boot。它是 Java 领域最主流的快速开发框架，生态完善，能极大简化 Web 服务开发。配合 Spring Data JPA 操作数据库，Spring MVC 提供 API。
• 数据库：MySQL。关系型数据库，适合存储结构化的设备信息、用户信息。对于时间序列的温度数据，也可以使用 MySQL，但若数据量极大，可考虑 InfluxDB。
• 前端：Vue.js + Element UI。对于 Java 后端开发者，Vue 易于上手，能快速构建美观的管理界面。如果时间紧迫，也可以直接使用 Thymeleaf 模板引擎在 Spring Boot 中渲染简单页面。
• 数据模拟/处理：Python。如果你的课题强调数据分析或算法（如预测温度趋势），可以用 Python 编写数据处理脚本，通过 HTTP 请求或消息队列与 Java 后端交互。
• 项目管理：Maven。管理项目依赖。

为什么这样选型？Spring Boot 内置了 Tomcat 服务器，无需复杂配置即可启动 Web 服务；它的“约定大于配置”理念，能让初学者避开繁琐的 XML 配置。MySQL 安装普及，图形化工具多。Vue 和 Element UI 提供了丰富的现成组件，比从零写 HTML/CSS/JS 快得多。这个组合在毕业设计层面，能平衡学习成本、开发效率和项目完整性。

2. 搭建 Spring Boot 后端开发环境

环境是项目能跑起来的基础。很多“源码跑不起来”的问题，都源于环境不一致。

2.1 基础环境准备

首先确保你的开发机上已安装以下软件，并确认版本。

常见坑点 1：Java 环境变量配置错误现象：在命令行执行java或javac提示“不是内部或外部命令”。 检查与解决：

1. 确认 JDK 已安装，并知道安装路径（如C:\Program Files\Java\jdk1.8.0_301）。
2. 配置系统环境变量JAVA_HOME，值为上述 JDK 安装路径。
3. 在Path变量中添加%JAVA_HOME%\bin。
4. 重新打开命令行终端，再次执行java -version验证。

常见坑点 2：Maven 仓库下载慢现象：第一次创建 Spring Boot 项目时，依赖下载极慢或失败。 解决：配置 Maven 的settings.xml文件（通常在conf目录下），使用国内镜像源。

<mirror> <id>aliyunmaven</id> <mirrorOf>*</mirrorOf> <name>阿里云公共仓库</name> <url>https://maven.aliyun.com/repository/public</url> </mirror>

2.2 初始化 Spring Boot 项目

使用 Spring Initializr 是创建项目最标准的方式。你可以通过 IDEA 内置的向导，或访问 start.spring.io 网站生成项目骨架。

关键依赖选择： 在 Initializr 页面或 IDEA 向导中，需要勾选以下依赖：

• Spring Web：用于构建 Web API。
• Spring Data JPA：用于简化数据库操作。
• MySQL Driver：连接 MySQL 数据库。
• Lombok（推荐）：通过注解自动生成 Getter/Setter 等方法，让实体类代码更简洁。

生成的项目会是一个标准的 Maven 项目，结构如下：

cold-chain-monitor/ ├── src/ │ ├── main/ │ │ ├── java/com/example/demo/ │ │ │ ├── ColdChainMonitorApplication.java // 主启动类 │ │ │ ├── controller/ // 控制器层，接收HTTP请求 │ │ │ ├── entity/ // 实体类，对应数据库表 │ │ │ ├── repository/ // 数据访问层，JPA接口 │ │ │ ├── service/ // 业务逻辑层 │ │ │ └── dto/ // 数据传输对象 │ │ └── resources/ │ │ ├── application.properties // 主配置文件 │ │ └── static/ // 静态资源（如前端打包文件） │ └── test/ // 测试代码 └── pom.xml // Maven依赖配置文件

2.3 配置数据库连接

在src/main/resources/application.properties文件中，配置 MySQL 数据库连接信息。

# 应用服务器端口 server.port=8080 # 数据库连接配置 spring.datasource.url=jdbc:mysql://localhost:3306/cold_chain_db?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai spring.datasource.username=root spring.datasource.password=your_password # 替换为你的MySQL root密码 spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver # JPA 配置 spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect spring.jpa.hibernate.ddl-auto=update # 启动时根据实体类自动更新表结构，生产环境慎用 spring.jpa.show-sql=true # 在控制台打印SQL语句，便于调试

配置解释：

• ddl-auto=update：Hibernate 会在应用启动时检查实体类与数据库表的差异，并自动更新表结构。这在开发阶段非常方便，但生产环境绝对不要使用，应改为validate或使用 Flyway/Liquibase 进行版本化迁移。
• show-sql=true：在控制台输出执行的 SQL 语句，是调试 SQL 问题的利器。

操作检查点：

1. 启动 MySQL，并手动创建一个名为cold_chain_db的空数据库（CREATE DATABASE cold_chain_db;）。
2. 运行主启动类ColdChainMonitorApplication中的main方法。
3. 观察控制台日志，如果没有出现数据库连接错误，并且最后看到类似Tomcat started on port(s): 8080的日志，说明后端基础环境搭建成功。

3. 设计与实现核心业务模块

我们将围绕“设备管理”、“温度数据上报”、“报警规则”三个核心功能展开。

3.1 定义数据库实体（Entity）

根据需求，我们至少需要三张表：设备表、温度数据记录表、报警记录表。

实体类：Device (设备)

package com.example.coldchain.entity; import lombok.Data; import javax.persistence.*; import java.time.LocalDateTime; @Entity @Table(name = "device") @Data // Lombok 注解，自动生成 getter, setter, toString 等 public class Device { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(unique = true, nullable = false) private String deviceId; // 设备唯一标识，如传感器SN号 private String deviceName; // 设备名称 private String location; // 设备位置，如“冷库A区” private String status; // 状态： ONLINE（在线）, OFFLINE（离线） private Double minTempThreshold; // 最低温度阈值 private Double maxTempThreshold; // 最高温度阈值 private LocalDateTime createTime; private LocalDateTime updateTime; @PrePersist protected void onCreate() { createTime = LocalDateTime.now(); updateTime = LocalDateTime.now(); } @PreUpdate protected void onUpdate() { updateTime = LocalDateTime.now(); } }

实体类：TemperatureRecord (温度记录)

package com.example.coldchain.entity; import lombok.Data; import javax.persistence.*; import java.time.LocalDateTime; @Entity @Table(name = "temperature_record") @Data public class TemperatureRecord { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @ManyToOne // 多对一关联，一条记录属于一个设备 @JoinColumn(name = "device_id", referencedColumnName = "deviceId") private Device device; private Double temperature; // 温度值 private Double humidity; // 湿度值（可选） private LocalDateTime recordTime; // 数据上报时间 private Boolean isAlarm = false; // 该条记录是否触发报警 private String alarmReason; // 报警原因，如“超上限” }

实体类：AlarmLog (报警日志)

package com.example.coldchain.entity; import lombok.Data; import javax.persistence.*; import java.time.LocalDateTime; @Entity @Table(name = "alarm_log") @Data public class AlarmLog { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @ManyToOne @JoinColumn(name = "device_id", referencedColumnName = "deviceId") private Device device; private Double alarmTemp; // 触发报警的温度值 private String alarmType; // 报警类型：HIGH（过高）, LOW（过低） private String alarmMsg; // 报警信息 private LocalDateTime alarmTime; private Boolean handled = false; // 是否已处理 private LocalDateTime handleTime; private String handler; // 处理人 }

关键点解释：

• @Entity和@Table将 Java 类映射到数据库表。
• @Id和@GeneratedValue定义主键及其自增策略。
• @ManyToOne定义了 TemperatureRecord 与 Device 的多对一关系，这是 JPA 中处理外键关联的标准方式。
• @PrePersist和@PreUpdate是生命周期回调，用于自动设置创建和更新时间。
• 使用LocalDateTime而非Date是 Java 8 后的最佳实践。

3.2 实现数据访问层（Repository）

Spring Data JPA 的强大之处在于，只需定义接口，无需实现，就能完成基本CRUD操作。

DeviceRepository.java

package com.example.coldchain.repository; import com.example.coldchain.entity.Device; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; import java.util.Optional; @Repository public interface DeviceRepository extends JpaRepository<Device, Long> { // 通过设备ID查找设备 Optional<Device> findByDeviceId(String deviceId); // 查找所有在线设备 List<Device> findByStatus(String status); }

TemperatureRecordRepository.java

package com.example.coldchain.repository; import com.example.coldchain.entity.TemperatureRecord; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.Query; import org.springframework.data.repository.query.Param; import java.time.LocalDateTime; import java.util.List; public interface TemperatureRecordRepository extends JpaRepository<TemperatureRecord, Long> { // 查找某个设备最近N条记录 List<TemperatureRecord> findTop10ByDevice_DeviceIdOrderByRecordTimeDesc(String deviceId); // 自定义查询：查找某设备在某个时间范围内的记录 @Query("SELECT tr FROM TemperatureRecord tr WHERE tr.device.deviceId = :deviceId AND tr.recordTime BETWEEN :start AND :end ORDER BY tr.recordTime DESC") List<TemperatureRecord> findByDeviceAndTimeRange(@Param("deviceId") String deviceId, @Param("start") LocalDateTime start, @Param("end") LocalDateTime end); }

只需继承JpaRepository<实体类, 主键类型>，就自动拥有了save(),findById(),findAll(),deleteById()等方法。方法名遵循特定规则（如findByStatus），JPA 能自动解析并生成对应 SQL。

3.3 实现业务逻辑层（Service）

Service 层封装复杂的业务规则，例如判断温度是否超标并创建报警。

TemperatureService.java (核心)

package com.example.coldchain.service; import com.example.coldchain.entity.*; import com.example.coldchain.repository.*; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import java.time.LocalDateTime; import java.util.Optional; @Service @Slf4j @RequiredArgsConstructor // Lombok 自动生成构造器，用于注入Repository public class TemperatureService { private final DeviceRepository deviceRepository; private final TemperatureRecordRepository recordRepository; private final AlarmLogRepository alarmLogRepository; /** * 处理温度数据上报 * @param deviceId 设备ID * @param temperature 上报的温度值 * @param humidity 湿度（可选） * @return 处理后的记录，包含是否报警信息 */ @Transactional public TemperatureRecord handleTemperatureData(String deviceId, Double temperature, Double humidity) { // 1. 查找设备 Optional<Device> deviceOpt = deviceRepository.findByDeviceId(deviceId); if (!deviceOpt.isPresent()) { log.warn("设备不存在: {}", deviceId); // 可以在这里选择创建新设备或抛出异常 throw new RuntimeException("设备未注册"); } Device device = deviceOpt.get(); // 2. 创建温度记录 TemperatureRecord record = new TemperatureRecord(); record.setDevice(device); record.setTemperature(temperature); record.setHumidity(humidity); record.setRecordTime(LocalDateTime.now()); // 3. 检查阈值，判断是否报警 boolean isAlarm = false; String alarmReason = null; if (device.getMaxTempThreshold() != null && temperature > device.getMaxTempThreshold()) { isAlarm = true; alarmReason = "温度超过上限阈值 " + device.getMaxTempThreshold(); createAlarmLog(device, temperature, "HIGH", alarmReason); } else if (device.getMinTempThreshold() != null && temperature < device.getMinTempThreshold()) { isAlarm = true; alarmReason = "温度低于下限阈值 " + device.getMinTempThreshold(); createAlarmLog(device, temperature, "LOW", alarmReason); } record.setIsAlarm(isAlarm); record.setAlarmReason(alarmReason); // 4. 更新设备状态为在线 device.setStatus("ONLINE"); device.setUpdateTime(LocalDateTime.now()); deviceRepository.save(device); // 由于是托管状态，通常可省略，但显式保存更清晰 // 5. 保存温度记录 return recordRepository.save(record); } private void createAlarmLog(Device device, Double temp, String type, String msg) { AlarmLog alarm = new AlarmLog(); alarm.setDevice(device); alarm.setAlarmTemp(temp); alarm.setAlarmType(type); alarm.setAlarmMsg(msg); alarm.setAlarmTime(LocalDateTime.now()); alarmLogRepository.save(alarm); log.info("设备 {} 触发报警: {}", device.getDeviceId(), msg); // 在实际项目中，这里可以集成短信、邮件、WebSocket 实时推送等通知方式 } }

业务逻辑详解：

1. 事务管理：@Transactional注解确保整个方法在一个数据库事务中执行，要么全部成功，要么全部回滚。
2. 设备查找：先校验设备是否存在，这是数据完整性的基础。
3. 阈值判断：核心业务规则。比较上报温度与设备预设的上下限阈值。
4. 状态更新：每次上报数据都更新设备状态为“在线”，这是实现设备在线状态监控的简单方法。
5. 报警创建：当触发报警时，不仅标记温度记录，还创建独立的报警日志，便于后续查询和处理。

3.4 实现控制器层（Controller）

Controller 负责对外提供 HTTP API 接口。

DeviceController.java (设备管理)

package com.example.coldchain.controller; import com.example.coldchain.entity.Device; import com.example.coldchain.service.DeviceService; import lombok.RequiredArgsConstructor; import org.springframework.web.bind.annotation.*; import java.util.List; @RestController @RequestMapping("/api/device") @RequiredArgsConstructor public class DeviceController { private final DeviceService deviceService; @GetMapping public List<Device> getAllDevices() { return deviceService.findAll(); } @GetMapping("/{deviceId}") public Device getDevice(@PathVariable String deviceId) { return deviceService.findByDeviceId(deviceId); } @PostMapping public Device createDevice(@RequestBody Device device) { return deviceService.createDevice(device); } @PutMapping("/{id}") public Device updateDevice(@PathVariable Long id, @RequestBody Device device) { device.setId(id); return deviceService.updateDevice(device); } @DeleteMapping("/{id}") public void deleteDevice(@PathVariable Long id) { deviceService.deleteDevice(id); } }

TemperatureController.java (数据上报与查询)

package com.example.coldchain.controller; import com.example.coldchain.entity.TemperatureRecord; import com.example.coldchain.service.TemperatureService; import lombok.RequiredArgsConstructor; import org.springframework.web.bind.annotation.*; import java.util.Map; @RestController @RequestMapping("/api/temperature") @RequiredArgsConstructor public class TemperatureController { private final TemperatureService temperatureService; // 模拟设备上报数据的接口 @PostMapping("/report") public TemperatureReportResult report(@RequestBody TemperatureReportRequest request) { TemperatureRecord record = temperatureService.handleTemperatureData( request.getDeviceId(), request.getTemperature(), request.getHumidity() ); return new TemperatureReportResult(true, "数据接收成功", record.getIsAlarm(), record.getAlarmReason()); } // 内部类，用于定义请求和响应的数据结构 @Data // 记得在类上使用 Lombok 的 @Data static class TemperatureReportRequest { private String deviceId; private Double temperature; private Double humidity; } @Data static class TemperatureReportResult { private boolean success; private String message; private boolean alarmTriggered; private String alarmInfo; // 构造器... } }

API 设计要点：

• @RestController表明这是一个 REST API 控制器，返回值会自动序列化为 JSON。
• @RequestMapping定义了 API 的基础路径。
• @GetMapping,@PostMapping等注解对应 HTTP 方法。
• @PathVariable用于获取 URL 路径中的变量，@RequestBody用于接收 JSON 格式的请求体。
• 为 API 定义清晰的请求和响应对象（如TemperatureReportRequest），而不是直接使用实体类，这能更好地控制输入输出，提高安全性。

4. 模拟数据上报与系统联调测试

后端服务写好后，需要验证它是否能正确工作。我们可以用多种方式模拟设备上报。

4.1 使用 Python 脚本模拟传感器数据

如果你的毕设涉及多语言或想体现数据处理能力，可以用 Python 编写一个简单的数据模拟器。

simulate_sensor.py

import requests import time import random import json # 配置 API_URL = "http://localhost:8080/api/temperature/report" DEVICE_ID = "sensor-001" INTERVAL_SECONDS = 5 # 每5秒上报一次 def simulate_temperature(base_temp=4.0): """模拟温度波动，偶尔产生异常值""" fluctuation = random.uniform(-0.5, 0.5) # 有5%的概率模拟一个异常高温或低温 if random.random() < 0.05: if random.choice([True, False]): return base_temp + random.uniform(3, 5) # 异常高 else: return base_temp - random.uniform(3, 5) # 异常低 return base_temp + fluctuation def send_data(device_id, temp, humidity): payload = { "deviceId": device_id, "temperature": round(temp, 2), "humidity": round(humidity, 2) if humidity is not None else None } headers = {'Content-Type': 'application/json'} try: response = requests.post(API_URL, data=json.dumps(payload), headers=headers) if response.status_code == 200: result = response.json() print(f"上报成功: 温度{temp:.2f}°C, 湿度{humidity:.1f}% -> 报警: {result.get('alarmTriggered')}, 信息: {result.get('alarmInfo')}") else: print(f"上报失败: HTTP {response.status_code}, {response.text}") except requests.exceptions.ConnectionError: print("错误: 无法连接到服务器，请确保后端服务已启动。") if __name__ == "__main__": print(f"开始模拟设备 {DEVICE_ID} 上报数据...") while True: current_temp = simulate_temperature() current_humidity = random.uniform(50.0, 70.0) # 模拟湿度 send_data(DEVICE_ID, current_temp, current_humidity) time.sleep(INTERVAL_SECONDS)

运行前准备：

1. 确保 Spring Boot 应用正在运行（端口 8080）。
2. 在 MySQL 中，通过 API 或数据库工具先插入一条设备记录，并设置阈值（例如，deviceId='sensor-001',minTempThreshold=2.0,maxTempThreshold=8.0）。
3. 安装 Python 的requests库：pip install requests。
4. 运行脚本：python simulate_sensor.py。

4.2 使用 Postman 或 curl 手动测试 API

对于快速调试，使用 API 测试工具更直接。

创建设备 (POST /api/device)

curl -X POST http://localhost:8080/api/device \ -H "Content-Type: application/json" \ -d '{ "deviceId": "sensor-002", "deviceName": "冷库入口传感器", "location": "A区入口", "status": "ONLINE", "minTempThreshold": 2.0, "maxTempThreshold": 8.0 }'

上报温度数据 (POST /api/temperature/report)

curl -X POST http://localhost:8080/api/temperature/report \ -H "Content-Type: application/json" \ -d '{ "deviceId": "sensor-002", "temperature": 9.5, "humidity": 65.0 }'

预期返回结果会包含alarmTriggered: true和alarmInfo: "温度超过上限阈值 8.0"。

查询设备最新数据 (GET /api/temperature/device/sensor-002/recent)（需要你在 TemperatureController 中实现这个接口）

@GetMapping("/device/{deviceId}/recent") public List<TemperatureRecord> getRecentRecords(@PathVariable String deviceId) { return temperatureService.getRecentRecords(deviceId, 10); }

4.3 验证数据库状态

通过 MySQL 客户端或 IDEA 的数据库工具，连接cold_chain_db数据库，检查表数据是否正常生成。

-- 查看设备表 SELECT * FROM device; -- 查看温度记录，看是否有报警标记 SELECT id, device_id, temperature, is_alarm, alarm_reason, record_time FROM temperature_record ORDER BY record_time DESC LIMIT 5; -- 查看报警日志 SELECT * FROM alarm_log ORDER BY alarm_time DESC;

如果数据都能正确插入，且报警逻辑生效（当温度超过8度或低于2度时，temperature_record.is_alarm为 1，且alarm_log表有记录），说明核心业务链路已打通。

5. 前端界面快速搭建与集成

对于毕业设计，前端的目标是能清晰展示数据即可。这里提供两种快速方案。

5.1 方案一：使用 Thymeleaf 模板引擎（纯后端）

如果你不熟悉 Vue 或 Node.js，Spring Boot 整合 Thymeleaf 是最快的方式。它允许你在后端直接渲染 HTML。

1. 添加依赖：在pom.xml中加入spring-boot-starter-thymeleaf。
2. 创建简单页面：在src/main/resources/templates下创建monitor.html。

   <!DOCTYPE html> <html xmlns:th="http://www.thymeleaf.org"> <head> <meta charset="UTF-8"> <title>冷链温控监控平台</title> <script src="https://cdn.jsdelivr.net/npm/echarts@5.4.3/dist/echarts.min.js"></script> </head> <body> <h1>设备实时监控</h1> <div> <label>选择设备：</label> <select id="deviceSelect"> <!-- 设备列表将通过后端动态填充 --> <option th:each="device : ${devices}" th:value="${device.deviceId}" th:text="${device.deviceName}"></option> </select> </div> <div id="chart" style="width: 800px;height:400px;"></div> <div> <h3>实时数据</h3> <p>温度：<span id="currentTemp">--</span> °C</p> <p>状态：<span id="currentStatus">--</span></p> <p>报警：<span id="currentAlarm">无</span></p> </div> <script> // 使用 Fetch API 或 Axios 从后端 /api/temperature/device/{id}/recent 获取数据 // 使用 ECharts 绘制温度曲线图 // 此处省略具体JavaScript代码，核心是调用我们之前写的API </script> </body> </html>

3. 创建 Controller 返回页面和数据：

   @Controller // 注意是 @Controller，不是 @RestController @RequestMapping("/view") public class MonitorViewController { @GetMapping("/monitor") public String monitorPage(Model model) { // 获取设备列表，放入模型 List<Device> devices = deviceService.findAll(); model.addAttribute("devices", devices); return "monitor"; // 对应 templates/monitor.html } }

4. 访问http://localhost:8080/view/monitor即可看到页面。

5.2 方案二：使用 Vue.js 前后端分离

这是更现代、更专业的方式。前端项目独立开发，通过调用后端 REST API 获取数据。

1. 初始化 Vue 项目：使用 Vue CLI 创建项目：vue create cold-chain-frontend。
2. 安装依赖：npm install axios echarts element-ui --save。
3. 开发主要组件：创建DeviceMonitor.vue组件，使用 Axios 调用后端 API（如http://localhost:8080/api/device），使用 ECharts 绘制图表，使用 Element UI 构建表格和表单。
4. 配置代理：在vue.config.js中配置开发服务器代理，解决跨域问题。

   module.exports = { devServer: { proxy: { '/api': { target: 'http://localhost:8080', // 后端地址 changeOrigin: true } } } }

5. 打包部署：开发完成后，运行npm run build生成静态文件（dist文件夹），将其复制到 Spring Boot 项目的src/main/resources/static目录下。这样 Spring Boot 启动后就可以直接通过根路径访问前端应用。

选择建议：如果时间有限或前端不是重点，选择方案一（Thymeleaf），它能让你快速得到一个可演示的界面。如果想展示更全面的技术栈或界面更美观，选择方案二（Vue）。

6. 毕业设计中的常见问题与排查路径

即使按照步骤操作，你也可能会遇到问题。以下是基于这个项目的典型排查清单。

关于“白漂源码”的忠告： 网络上流传的“万套毕设源码”质量参差不齐。直接使用可能遇到：1) 代码结构混乱，难以理解和修改；2) 依赖老旧，无法在当前环境运行；3) 数据库缺失或脚本错误；4) 功能残缺，无法满足答辩要求。最好的方式是以一份结构清晰的源码为蓝本，自己动手重写核心业务逻辑。这样既能保证项目能跑起来，又能真正理解代码，应对答辩提问。

7. 从原型到完整毕设的扩展方向与最佳实践

一个能运行的 Demo 只是开始，要成为一份优秀的毕业设计，还需要考虑以下方面：

7.1 功能扩展建议

1. 用户管理与权限控制：集成 Spring Security，实现不同角色（管理员、普通用户）的登录和权限控制。
2. 数据可视化增强：
   • 实时推送：使用 WebSocket（如 STOMP over WebSocket）实现温度数据的实时推送，让图表自动刷新。
   • 历史数据查询：提供按时间范围、设备查询历史数据并导出报表的功能。
   • 大屏展示：使用 ECharts 或 AntV 制作监控大屏，展示多个设备的实时状态和统计信息。
3. 报警通知多元化：除了记录日志，可以集成邮件（Spring Mail）、短信（阿里云/腾讯云 SDK）或消息应用（如钉钉、企业微信机器人）进行实时告警。
4. 设备管理：增加设备分组、批量导入/导出、设备心跳检测（长时间无数据上报则标记为离线）等功能。
5. 数据分析与预测（可作为论文亮点）：利用 Python 脚本（或 Java 集成 ML 库）对历史温度数据进行分析，实现简单的异常检测或趋势预测，并将结果通过 API 返回给前端展示。

7.2 工程化与部署最佳实践

1. 配置文件分离：将application.properties拆分为application-dev.yml（开发）、application-prod.yml（生产），使用spring.profiles.active激活不同环境配置。生产环境的数据库密码、API密钥等应使用环境变量或配置中心管理。
2. 日志记录：使用 SLF4J + Logback，合理配置日志级别和输出格式。关键业务操作（如报警触发、设备上下线）必须记录 INFO 或 WARN 级别日志。
3. 异常处理：定义全局异常处理器（@ControllerAdvice），统一处理业务异常和系统异常，返回结构化的错误信息给前端，而不是暴露堆栈信息。
4. API 文档：使用 Swagger/OpenAPI 自动生成 API 文档，方便前端联调和答辩演示。在pom.xml中引入springdoc-openapi-ui依赖即可。
5. 单元测试：为 Service 层关键方法编写单元测试（JUnit + Mockito），确保核心业务逻辑正确。这是体现工程素养的重要部分。
6. 部署：学习使用 Docker 将应用容器化，编写Dockerfile和docker-compose.yml，可以一键启动整个系统（包含 MySQL、后端、前端），极大简化部署流程，也是答辩的加分项。

7.3 论文与答辩准备

1. 系统架构图：用 Draw.io 或 ProcessOn 绘制清晰的系统架构图，展示前端、后端、数据库、传感器之间的关系。
2. 数据库设计：给出完整的 E-R 图和数据表结构说明。
3. 核心代码说明：在论文中贴出关键代码（如报警判断逻辑、数据上报接口），并加以解释。
4. 功能演示：准备一个完整的演示流程：用户登录 -> 查看设备列表 -> 模拟数据上报 -> 查看实时图表 -> 触发报警 -> 查看报警日志 -> 处理报警。
5. 应对提问：深入理解自己写的代码，准备好回答诸如“为什么用 Spring Boot？”、“JPA 和 MyBatis 有什么区别？”、“如何保证数据的一致性？”、“如果传感器数据量非常大，系统如何优化？”等问题。

通过以上步骤，你不仅得到了一个可运行的“冷链监控平台温控系统”项目，更掌握了一套从零开始构建一个完整 Spring Boot 应用的方法论。记住，毕业设计的价值不在于代码量，而在于你对技术选型的思考、对业务逻辑的实现以及对问题的解决能力。从这个项目出发，你可以根据自己论文的方向，向深度或广度进行扩展，最终形成一份属于你自己的、高质量的毕业设计。