一、项目背景

在大学生四人寝室场景中，存在 “奇妙物种”引发的多维度冲突，核心痛点集中在行为干扰（噪音、作息冲突）、空间侵占（物品乱堆、公共区域占用）、卫生问题（乱扔垃圾、个人卫生差）、沟通失效（阴阳怪气、屡教不改）四大领域。传统 “口头沟通”“忍字当头” 的解决方案已失效，需通过技术手段构建 “客观记录 - 规则约束 - 证据留存 - 协同管理” 的闭环体系，最终实现 “非接触式冲突规避” 与 “有理有据维权”，而非单纯 “忍受”。

本方案基于 Vue（前端）、SpringBoot/SpringCloud（微服务后端）、Nacos（服务注册发现）、K8s（容器化部署）、AES/SHA-256 等加密算法、云原生数据库，构建 “和谐寝室生态管理系统”，将寝室生活中的 “主观矛盾” 转化为 “客观数据”，用技术工具降低人为冲突概率，同时留存证据以应对后续可能的调解或维权需求。

二、技术栈选型与核心架构设计

1. 技术栈全景图

技术层级	核心技术	选型理由	解决的寝室场景问题
前端层	Vue 3 + Vite + Element Plus	轻量高效、组件化强，支持移动端适配，方便室友随时记录数据	移动端 / PC 端快速录入行为记录、查看寝室规则
微服务后端	SpringBoot 2.7.x + SpringCloud Alibaba	微服务拆分灵活，支持服务独立部署与扩展	拆分 “行为记录”“规则管理”“证据存储” 等模块，互不影响
服务注册与配置	Nacos 2.2.x	动态配置管理、服务发现，支持多环境（开发 / 生产）	寝室成员数据权限动态调整，规则更新无需重启服务
容器化部署	K8s + Docker	服务高可用，支持资源动态分配，可部署在云服务器或本地虚拟机	确保系统 7x24 小时运行，避免记录数据丢失
高性能计算	C++ 高性能服务器（基于 muduo 网络库）	处理高并发的行为日志写入、实时噪音检测等计算密集型任务	实时采集噪音数据、设备状态（如阳台占用检测）
数据库	云原生数据库（如阿里云 PolarDB）	支持分布式存储、高并发读写，数据持久化可靠	存储寝室行为记录、证据文件元数据、成员权限数据
加密算法	AES-256（对称加密）、SHA-256（哈希）、RSA（非对称加密）	AES 加密敏感数据，SHA-256 防数据篡改，RSA 签名验证身份	保护室友隐私（如记录人信息），确保证据不被篡改
边缘设备集成	树莓派（带麦克风、摄像头、人体传感器）	低成本边缘计算设备，支持本地数据采集与预处理	实时检测噪音、记录公共区域占用、拍摄卫生问题证据

2. 系统整体架构（分层设计）

（1）感知层：客观数据采集，告别 “主观扯皮”

核心目标是将 “看不见的干扰”（如噪音）、“难量化的行为”（如物品乱堆）转化为 “可度量的数据”，避免 “你说他吵，他说你敏感” 的主观矛盾。

• 噪音采集模块：基于树莓派 + 麦克风，通过 C++ 高性能服务器实时采集寝室声音数据（采样率 44.1kHz），预处理后计算分贝值（参考标准：昼间≤55dB，夜间≤45dB），当超过阈值时自动触发记录（含时间戳、分贝值），并可关联摄像头拍摄当时场景（可选，需提前告知室友以合规）。
• 空间占用检测：在阳台、公共桌面等区域安装红外人体传感器或超声波测距模块，通过边缘计算记录 “某区域被占用时长”（如阳台被某室友占用超过 2 小时 / 天），并结合摄像头拍摄物品堆放情况（存储为图片，自动添加水印时间戳）。
• 卫生问题记录：支持室友通过手机端 Vue 应用主动上传卫生问题照片（如乱扔的鼻涕纸、占用他人床铺的衣服），上传时自动添加 GPS 定位（寝室位置）、时间戳，且图片文件通过 AES-256 加密后传输至云端。
• 作息行为记录：通过智能插座（如小米智能插座，接入系统）记录某室友使用大功率电器（如吹风机）的时间（如凌晨 1 点使用），或通过灯光传感器记录某区域夜间亮灯时长（间接反映熬夜影响他人）。

（2）传输层：加密传输，确保数据不泄露、不篡改

• 边缘端到云端：边缘设备（树莓派）采集的数据先通过 SHA-256 计算哈希值（生成数据指纹），再用 AES-256 加密（密钥由 Nacos 动态下发，每 24 小时更新），通过 MQTT 协议传输至云端网关（SpringCloud Gateway）。
• 前端到后端：用户（室友）通过 Vue 应用提交的记录（如卫生问题反馈），采用 HTTPS 协议传输，请求头中携带 JWT 令牌（基于 RSA 非对称加密签名），令牌中包含用户身份（如 “寝室 101 - 成员 A”）、权限等级（如 “普通成员可提交记录，管理员可查看所有记录”），防止未授权用户访问。
• 服务间通信：微服务之间（如 “行为记录服务” 调用 “证据存储服务”）通过 gRPC 协议通信，请求参数通过 SHA-256 哈希校验，确保传输过程中数据不被篡改。

（3）业务层：微服务拆分，聚焦核心场景解决

基于 SpringCloud Alibaba 将业务拆分为 5 个核心微服务，通过 Nacos 实现服务注册与配置管理，每个服务独立部署在 K8s 容器中，支持水平扩展。

微服务名称	核心功能	解决的寝室痛点	技术依赖
行为记录服务（record-service）	接收感知层数据，存储 “噪音记录”“空间占用记录”“作息记录”，提供多条件查询（如 “近 7 天夜间超过 45dB 的记录”）	客观记录奇妙行为，避免 “无凭无据”	SpringBoot、MyBatis-Plus、云原生数据库
证据管理服务（evidence-service）	存储加密后的证据文件（图片、音频），生成唯一文件 ID，关联对应的行为记录，支持证据导出（用于辅导员调解）	留存维权证据，防止对方抵赖	MinIO（对象存储）、AES-256（文件加密）、SHA-256（文件哈希）
规则引擎服务（rule-service）	配置寝室规则（如 “23:00 后分贝≤40dB”“阳台个人物品占用≤1/4 区域”），当行为记录触发规则时自动生成提醒（如 APP 推送 “当前噪音超标，请降低音量”）	用规则约束行为，减少人为提醒冲突	Drools 规则引擎、Nacos 配置中心（动态更新规则）
成员权限服务（auth-service）	管理寝室成员身份（录入姓名、学号、联系方式），分配权限（如 “管理员” 由 3 个正常室友轮流担任），处理登录、JWT 令牌生成	确保数据隐私，防止记录被篡改	SpringSecurity、JWT、RSA 非对称加密
协同沟通服务（comm-service）	支持 “非接触式沟通”：如某室友想提醒对方 “声音太大”，可通过系统发送匿名提醒（仅显示 “寝室成员”，不显示具体人），提醒内容自动记录在系统中	避免面对面冲突，减少阴阳怪气	SpringBoot、WebSocket（实时推送提醒）

（4）存储层：加密存储 + 分布式，确保数据安全可靠

• 结构化数据存储：寝室成员信息、行为记录（时间戳、分贝值、区域占用时长）等结构化数据存储在云原生数据库（如阿里云 PolarDB），采用 “分库分表” 设计（按寝室 ID 分库，按时间分表），支持高并发读写。
• 非结构化数据存储：证据图片、音频等非结构化数据存储在 MinIO 对象存储（部署在 K8s 集群中），每个文件存储时执行两步处理：① 用 AES-256 加密文件内容；② 计算文件的 SHA-256 哈希值，存储在数据库中（用于后续校验文件是否被篡改）。
• 数据备份策略：采用 “本地备份 + 异地灾备”，结构化数据每小时增量备份，每天全量备份；非结构化数据通过 MinIO 的纠删码机制（EC）实现数据冗余（如设置 4+2 纠删码，允许 2 个节点故障不丢失数据）。

（5）展示层：Vue 前端，简洁易用的用户界面

前端采用 Vue 3 + Element Plus 构建，支持 PC 端（寝室电脑）和移动端（手机）适配，核心页面包括：

• 首页（仪表盘）：展示寝室当前状态（如 “当前分贝：38dB（正常）”“阳台占用率：30%（正常）”）、近 7 天违规记录统计（如 “夜间噪音超标 3 次”）。
• 行为记录页：按 “噪音”“空间占用”“卫生问题” 分类展示所有记录，支持筛选（如 “23:00-06:00 的记录”）、导出（生成 Excel 表格，用于辅导员调解）。
• 证据上传页：支持拍照 / 录像上传卫生问题证据，上传时自动添加水印（时间、寝室号），用户可添加备注（如 “2024-10-08 14:00，阳台有未扔的外卖盒”）。
• 规则配置页：管理员可修改寝室规则（如调整夜间噪音阈值），修改后需经过≥2 个室友确认才能生效（防止单人滥用权限）。
• 消息提醒页：展示系统自动生成的规则提醒（如 “23:10 分贝达到 52dB，已发送匿名提醒”）、其他室友的匿名沟通消息。

三、核心技术难点与解决方案

1. 数据隐私保护：避免 “记录” 变成 “监控”

问题痛点

若系统采集数据过于敏感（如摄像头实时监控），可能侵犯室友隐私，引发更严重冲突。

技术方案

• 数据采集最小化：仅采集与 “公共利益相关” 的数据，如噪音（公共区域声音）、阳台占用（公共区域空间），不采集室友私人区域（如书桌、床铺）的图像。
• 加密与权限控制：
  • 所有行为记录关联的用户信息（如 “谁提交的卫生记录”）通过 AES-256 加密存储，只有管理员（经多数室友授权）可解密查看，普通成员仅能查看记录内容，看不到提交人。
  • 摄像头拍摄的公共区域图片，自动模糊处理可能涉及隐私的部分（如室友的面部、私人用品上的文字）。
• 知情同意原则：系统部署前，需向所有室友公示数据采集范围、用途（仅用于寝室内部管理与辅导员调解），并签署电子确认书（通过 SHA-256 哈希存储确认记录，防止后续抵赖）。

2. 实时性与性能：确保噪音、行为记录不延迟

问题痛点

噪音、夜间违规行为等需要实时记录，若系统响应延迟，可能错过关键证据。

技术方案

• 边缘计算预处理：树莓派本地运行 C++ 高性能服务器（基于 muduo 网络库），实时计算分贝值、检测空间占用，仅当数据超过阈值时才上传至云端（减少网络传输量）。
• 高并发处理：云端 “行为记录服务” 采用 Netty 作为服务器，支持高并发 TCP 连接（处理多个边缘设备的实时数据上传），同时使用 Redis 缓存近期的行为记录（如近 1 小时的噪音数据），减少数据库查询压力。
• K8s 动态扩缩容：通过 K8s 的 HPA（Horizontal Pod Autoscaler）配置，当 “行为记录服务” 的 CPU 使用率超过 70% 时，自动增加 Pod 副本数（如从 2 个扩至 4 个），确保高峰期系统性能。

3. 数据防篡改：确保证据有效

问题痛点

若奇妙室友质疑 “记录是伪造的”，需确保数据从采集到存储的全链路不可篡改。

技术方案

• 全链路哈希校验：
  1. 边缘设备采集数据后，立即计算 SHA-256 哈希值（数据指纹），并将 “数据 + 哈希值” 一起加密上传。
  2. 云端接收后，先验证哈希值是否与数据匹配（若不匹配，说明传输过程中被篡改，拒绝存储）。
  3. 数据存储到数据库后，定期（如每天凌晨）重新计算所有记录的哈希值，与存储的哈希值比对，若不一致则触发告警（可能有人篡改数据库）。
• 证据文件签名：证据图片、音频存储时，由管理员（或系统）用 RSA 私钥生成数字签名，存储在数据库中。当需要导出证据时，用对应的公钥验证签名（若签名不匹配，说明文件被篡改）。

4. 非接触式沟通：减少直接冲突

问题痛点

直接提醒奇妙室友可能引发争吵，需通过系统实现 “无情绪” 的沟通。

技术方案

• 匿名提醒机制：用户可发起匿名提醒（如 “当前声音较大，影响他人休息”），系统自动发送至对方的 APP，提醒内容中不包含发起人的信息，仅显示 “寝室成员提醒”。
• 规则自动提醒：当系统检测到违规行为（如分贝超标），无需用户操作，自动发送提醒（如 “23:15 检测到噪音 58dB，已超过夜间阈值，请降低音量”），提醒内容基于客观数据，避免主观指责。
• 沟通记录留存：所有通过系统的沟通消息（匿名提醒、规则提醒）均存储在数据库中，若后续需要调解，可导出作为 “已尝试沟通” 的证据。

四、系统核心模块设计与实现

4.1 噪音监控模块设计

噪音干扰是寝室冲突的核心诱因之一，尤其夜间 11 点后至次日早晨 7 点的噪音行为，直接影响成员休息质量。本模块通过 “边缘端实时采集 - 云端加密存储 - 前端可视化展示” 的三层架构，实现噪音数据的全链路管理，关键解决 “数据客观性”“实时性” 与 “隐私保护” 三大问题。边缘端基于树莓派与 C++ 高性能服务器实现噪音采集与预处理，云端通过 SpringBoot 微服务完成数据加密存储与规则校验，前端依托 Vue 构建可视化界面，支持噪音状态实时查看与历史记录追溯。

4.1.1 边缘端噪音采集实现（C++）

边缘端作为数据采集入口，需具备低延迟、低功耗特性，选用树莓派 4B 作为硬件载体，搭载 USB 麦克风模块（采样率 44.1kHz，采样精度 16bit），通过 C++ 基于 PortAudio 音频库实现声音采集，结合声压级计算公式将原始音频数据转换为分贝值（dB），并通过 AES-256 加密与 SHA-256 哈希确保数据传输安全性与完整性。

核心实现代码如下：

#include <iostream>
#include <vector>
#include <portaudio.h>
#include <cmath>
#include <ctime>
#include <cstring>
#include "AES.h"  // 自定义AES加密工具类
#include "SHA256.h"  // 自定义SHA-256哈希工具类

// 音频采集参数配置
#define SAMPLE_RATE 44100
#define FRAMES_PER_BUFFER 1024
#define CHANNELS 1
#define SAMPLE_FORMAT paInt16

// 寝室噪音阈值配置（夜间23:00-7:00为40dB，其余时段为55dB）
#define NIGHT_THRESHOLD 40.0
#define DAY_THRESHOLD 55.0

// AES加密密钥与初始化向量（实际部署通过Nacos动态获取）
const std::string AES_KEY = "DormSystem2024Key!";
const std::string AES_IV = "DormIV1234567890!";

// 全局变量：存储音频数据与分贝值
std::vector<int16_t> audioData;
double currentDB = 0.0;

// 音频流回调函数：实时采集音频数据
static int audioCallback(const void* inputBuffer, void* outputBuffer,
                         unsigned long framesPerBuffer,
                         const PaStreamCallbackTimeInfo* timeInfo,
                         PaStreamCallbackFlags statusFlags,
                         void* userData) {
    const int16_t* in = static_cast<const int16_t*>(inputBuffer);
    (void)outputBuffer;  // 无需输出，仅采集

    // 读取当前帧音频数据
    for (unsigned long i = 0; i < framesPerBuffer; i++) {
        audioData.push_back(in[i]);
    }

    // 每采集10帧数据计算一次分贝值（约0.23秒）
    if (audioData.size() >= FRAMES_PER_BUFFER * 10) {
        double sum = 0.0;
        // 计算音频数据的均方根（RMS）
        for (auto sample : audioData) {
            double val = sample / 32768.0;  // 转换为[-1,1]范围
            sum += val * val;
        }
        double rms = sqrt(sum / audioData.size());
        // 转换为分贝值（参考声压20μPa）
        currentDB = 20 * log10(rms / 0.00002);
        audioData.clear();

        // 获取当前时间，判断是否为夜间时段
        time_t now = time(nullptr);
        tm* localTime = localtime(&now);
        bool isNight = (localTime->tm_hour >= 23 || localTime->tm_hour < 7);
        double threshold = isNight ? NIGHT_THRESHOLD : DAY_THRESHOLD;

        // 若超标，生成加密数据并准备上传
        if (currentDB > threshold) {
            // 构造数据结构体：时间戳、分贝值、阈值、寝室ID
            struct NoiseData {
                char dormId[10];
                char timestamp[20];
                double dbValue;
                double threshold;
            } noiseData;

            strcpy(noiseData.dormId, "101");  // 寝室ID（101室）
            strftime(noiseData.timestamp, sizeof(noiseData.timestamp), 
                     "%Y-%m-%d %H:%M:%S", localTime);
            noiseData.dbValue = currentDB;
            noiseData.threshold = threshold;

            // 1. AES-256加密数据（CBC模式，PKCS7填充）
            AES aes;
            std::string plaintext(reinterpret_cast<char*>(&noiseData), sizeof(NoiseData));
            std::string encryptedData = aes.encrypt(plaintext, AES_KEY, AES_IV);

            // 2. SHA-256计算数据哈希（确保完整性）
            SHA256 sha256;
            std::string dataHash = sha256.calculate(plaintext);

            // 3. 输出日志（实际场景中通过MQTT上传至云端）
            std::cout << "[超标记录] " << noiseData.timestamp 
                      << " | 分贝值: " << noiseData.dbValue 
                      << " | 加密数据: " << encryptedData.substr(0, 20) << "..." 
                      << " | 数据哈希: " << dataHash << std::endl;
        }
    }

    return paContinue;
}

// 初始化音频流并启动采集
int main() {
    PaError err;
    PaStream* stream;

    // 初始化PortAudio
    err = Pa_Initialize();
    if (err != paNoError) {
        std::cerr << "PortAudio初始化失败: " << Pa_GetErrorText(err) << std::endl;
        return 1;
    }

    // 打开音频流（仅输入）
    err = Pa_OpenDefaultStream(&stream, CHANNELS, 0, SAMPLE_FORMAT,
                               SAMPLE_RATE, FRAMES_PER_BUFFER, audioCallback, nullptr);
    if (err != paNoError) {
        std::cerr << "音频流打开失败: " << Pa_GetErrorText(err) << std::endl;
        Pa_Terminate();
        return 1;
    }

    // 启动采集
    err = Pa_StartStream(stream);
    if (err != paNoError) {
        std::cerr << "音频流启动失败: " << Pa_GetErrorText(err) << std::endl;
        Pa_CloseStream(stream);
        Pa_Terminate();
        return 1;
    }

    std::cout << "噪音采集已启动，按Enter键停止..." << std::endl;
    getchar();

    // 停止并关闭音频流
    err = Pa_StopStream(stream);
    if (err != paNoError) std::cerr << "音频流停止失败: " << Pa_GetErrorText(err) << std::endl;
    
    err = Pa_CloseStream(stream);
    if (err != paNoError) std::cerr << "音频流关闭失败: " << Pa_GetErrorText(err) << std::endl;
    
    Pa_Terminate();
    return 0;
}

上述代码中，音频采集通过 PortAudio 库实现，每采集 10 帧数据（约 0.23 秒）计算一次分贝值，避免高频计算导致的资源占用；时间戳与寝室 ID 作为数据标识，确保记录可追溯；AES-256 加密采用 CBC 模式，密钥与初始化向量通过 Nacos 动态下发（代码中为演示暂写死，实际部署需修改为配置中心获取逻辑），防止数据传输过程中被窃取；SHA-256 哈希用于云端接收数据后的完整性校验，若哈希值不匹配则拒绝存储，确保数据未被篡改。

4.1.2 云端数据处理服务实现（SpringBoot）

云端数据处理服务基于 SpringBoot 构建，属于 “行为记录服务”（record-service）的核心子模块，负责接收边缘端上传的加密噪音数据，完成解密、哈希校验、规则匹配与存储，并触发超标提醒。服务通过 Nacos 注册发现，数据库采用阿里云 PolarDB，非结构化证据（如超标时的环境照片）存储于 MinIO 对象存储。

数据解密与校验核心代码如下：

package com.dorm.system.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.dorm.system.entity.NoiseRecord;
import com.dorm.system.mapper.NoiseRecordMapper;
import com.dorm.system.service.NoiseRecordService;
import com.dorm.system.util.AesUtils;
import com.dorm.system.util.Sha256Utils;
import com.dorm.system.vo.NoiseDataVO;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

/**
 * 噪音记录服务实现类
 * 负责噪音数据的解密、校验、存储与超标提醒
 */
@Service
public class NoiseRecordServiceImpl extends ServiceImpl<NoiseRecordMapper, NoiseRecord> 
        implements NoiseRecordService {

    // AES密钥与IV（从Nacos配置中心获取，注解@Value自动注入）
    @Value("${dorm.encrypt.aes.key}")
    private String aesKey;

    @Value("${dorm.encrypt.aes.iv}")
    private String aesIv;

    // 时间格式化器
    private static final DateTimeFormatter DATETIME_FORMATTER = 
            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    /**
     * 处理边缘端上传的加密噪音数据
     * @param encryptedData 加密后的噪音数据（Base64编码）
     * @param dataHash 原始数据的SHA-256哈希值
     * @return 处理结果（成功/失败）
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean processEncryptedNoiseData(String encryptedData, String dataHash) {
        try {
            // 1. AES-256解密（CBC模式，PKCS7填充，Base64解码）
            String decryptedData = AesUtils.decrypt(encryptedData, aesKey, aesIv);
            if (decryptedData == null || decryptedData.isEmpty()) {
                log.error("噪音数据解密失败，加密数据: {}", encryptedData);
                return false;
            }

            // 2. SHA-256哈希校验（确保数据未被篡改）
            String calculatedHash = Sha256Utils.calculate(decryptedData);
            if (!calculatedHash.equals(dataHash)) {
                log.error("噪音数据哈希校验失败，接收哈希: {}, 计算哈希: {}", dataHash, calculatedHash);
                return false;
            }

            // 3. 解析解密后的数据（按边缘端定义的结构体格式拆分）
            NoiseDataVO noiseData = parseNoiseData(decryptedData);
            if (noiseData == null) {
                log.error("噪音数据解析失败，解密数据: {}", decryptedData);
                return false;
            }

            // 4. 构造数据库实体并存储
            NoiseRecord noiseRecord = new NoiseRecord();
            noiseRecord.setDormId(noiseData.getDormId());
            noiseRecord.setDbValue(noiseData.getDbValue());
            noiseRecord.setThreshold(noiseData.getThreshold());
            noiseRecord.setRecordTime(LocalDateTime.parse(noiseData.getTimestamp(), DATETIME_FORMATTER));
            noiseRecord.setIsOverThreshold(noiseData.getDbValue() > noiseData.getThreshold() ? 1 : 0);
            noiseRecord.setDataHash(dataHash);  // 存储哈希值，便于后续校验

            // 5. 保存记录（MyBatis-Plus实现）
            boolean saveResult = save(noiseRecord);
            if (!saveResult) {
                log.error("噪音记录存储失败，数据: {}", noiseRecord);
                return false;
            }

            // 6. 若超标，触发匿名提醒（调用协同沟通服务comm-service）
            if (noiseRecord.getIsOverThreshold() == 1) {
                triggerOverThresholdReminder(noiseRecord);
            }

            log.info("噪音数据处理成功，记录ID: {}", noiseRecord.getId());
            return true;

        } catch (Exception e) {
            log.error("噪音数据处理异常", e);
            return false;
        }
    }

    /**
     * 解析解密后的噪音数据（按边缘端C++结构体字段顺序拆分）
     * @param decryptedData 解密后的字符串
     * @return 噪音数据VO对象
     */
    private NoiseDataVO parseNoiseData(String decryptedData) {
        try {
            // 边缘端结构体字段：dormId(10字节) + timestamp(20字节) + dbValue(8字节) + threshold(8字节)
            NoiseDataVO vo = new NoiseDataVO();
            // 提取寝室ID（前10字节，去除空字符）
            vo.setDormId(decryptedData.substring(0, 10).trim());
            // 提取时间戳（10-30字节）
            vo.setTimestamp(decryptedData.substring(10, 30).trim());
            // 提取分贝值（30-38字节，转换为double）
            String dbValueStr = decryptedData.substring(30, 38).trim();
            vo.setDbValue(Double.parseDouble(dbValueStr));
            // 提取阈值（38-46字节，转换为double）
            String thresholdStr = decryptedData.substring(38, 46).trim();
            vo.setThreshold(Double.parseDouble(thresholdStr));
            return vo;
        } catch (Exception e) {
            log.error("数据解析异常", e);
            return null;
        }
    }

    /**
     * 触发噪音超标匿名提醒（通过Feign调用comm-service）
     * @param noiseRecord 超标记录
     */
    private void triggerOverThresholdReminder(NoiseRecord noiseRecord) {
        try {
            // 构造提醒内容（客观数据，无主观评价）
            String reminderContent = String.format(
                    "【寝室噪音提醒】%s，检测到噪音值%.1f dB，超过当前阈值%.1f dB，请降低音量，避免影响他人休息。",
                    noiseRecord.getRecordTime().format(DATETIME_FORMATTER),
                    noiseRecord.getDbValue(),
                    noiseRecord.getThreshold()
            );

            // 调用协同沟通服务的匿名提醒接口（Feign客户端）
            reminderFeignClient.sendAnonymousReminder(
                    noiseRecord.getDormId(),  // 目标寝室
                    "NOISE_OVER",  // 提醒类型
                    reminderContent  // 提醒内容
            );
            log.info("噪音超标提醒已发送，寝室ID: {}", noiseRecord.getDormId());
        } catch (Exception e) {
            log.error("超标提醒发送失败", e);
        }
    }
}

该服务实现了三大核心逻辑：一是数据安全校验，通过 AES 解密与 SHA-256 哈希校验，确保边缘端上传的数据未被窃取或篡改；二是结构化存储，将解析后的数据存储于 PolarDB，同时保留哈希值便于后续审计；三是自动提醒触发，若检测到噪音超标，通过 Feign 调用 “协同沟通服务” 发送匿名提醒，避免人工干预导致的冲突。

4.1.3 前端可视化界面实现（Vue）

前端可视化界面基于 Vue 3 + Element Plus 构建，属于 “寝室仪表盘” 模块的核心功能页，支持成员实时查看当前噪音状态、历史趋势图表与超标记录，关键设计目标是 “数据直观化” 与 “操作轻量化”。界面分为 “状态卡片”“趋势图表”“超标记录表格” 三部分，适配 PC 端与移动端，便于成员在不同场景下查看数据。

核心实现代码如下：

<template>
  <div class="noise-monitor-page">
    <!-- 页面标题 -->
    <el-page-header content="噪音监控" @back="handleBack"></el-page-header>

    <!-- 状态卡片区域 -->
    <el-row :gutter="20" class="status-card-row">
      <!-- 当前状态卡片 -->
      <el-col :span="12" :xs="24">
        <el-card :border="true" class="status-card">
          <div class="card-header">
            <el-icon class="card-icon"><SoundFilled /></el-icon>
            <span class="card-title">当前噪音状态</span>
          </div>
          <div class="card-content">
            <div class="db-value">
              {{ currentDb.toFixed(1) }} <span class="unit">dB</span>
            </div>
            <div class="status-tag">
              <el-tag :type="currentStatus === 'normal' ? 'success' : 'danger'">
                {{ currentStatus === 'normal' ? '正常' : '超标' }}
              </el-tag>
              <span class="threshold">阈值: {{ threshold.toFixed(1) }} dB</span>
            </div>
          </div>
        </el-card>
      </el-col>

      <!-- 今日统计卡片 -->
      <el-col :span="12" :xs="24">
        <el-card :border="true" class="status-card">
          <div class="card-header">
            <el-icon class="card-icon"><CalendarFilled /></el-icon>
            <span class="card-title">今日超标统计</span>
          </div>
          <div class="card-content">
            <div class="count-value">
              {{ todayOverCount }} <span class="unit">次</span>
            </div>
            <div class="last-over-time">
              <el-icon class="time-icon"><ClockFilled /></el-icon>
              <span class="time-text">最近超标: {{ lastOverTime || '无' }}</span>
            </div>
          </div>
        </el-card>
      </el-col>
    </el-row>

    <!-- 筛选与图表区域 -->
    <el-card :border="true" class="chart-card" style="margin-top: 20px;">
      <div class="chart-header">
        <span class="chart-title">噪音趋势图表</span>
        <div class="filter-group">
          <el-select v-model="timeRange" @change="fetchNoiseRecords" placeholder="选择时间范围" style="width: 160px; margin-right: 10px;">
            <el-option label="今日" value="today"></el-option>
            <el-option label="近7天" value="7days"></el-option>
            <el-option label="近30天" value="30days"></el-option>
            <el-option label="自定义" value="custom"></el-option>
          </el-select>
          <el-date-picker
            v-if="timeRange === 'custom'"
            v-model="dateRange"
            type="datetimerange"
            range-separator="至"
            start-placeholder="开始时间"
            end-placeholder="结束时间"
            @change="fetchNoiseRecords"
            style="width: 380px;"
          ></el-date-picker>
        </div>
      </div>
      <div class="chart-container">
        <el-skeleton v-if="loading" :rows="5" style="height: 300px;"></el-skeleton>
        <canvas id="noiseTrendChart" v-else style="width: 100%; height: 300px;"></canvas>
      </div>
    </el-card>

    <!-- 超标记录表格 -->
    <el-card :border="true" class="records-card" style="margin-top: 20px;">
      <div class="records-header">
        <span class="records-title">噪音超标记录</span>
        <el-button 
          type="primary" 
          size="mini" 
          @click="exportRecords"
          :disabled="overRecords.length === 0"
        >
          <el-icon><Download /></el-icon> 导出记录
        </el-button>
      </div>
      <el-table
        :data="overRecords"
        border
        stripe
        style="width: 100%; margin-top: 10px;"
        :empty-text="loading ? '加载中...' : '暂无超标记录'"
      >
        <el-table-column
          prop="recordTime"
          label="记录时间"
          width="180"
          :formatter="formatDateTime"
        ></el-table-column>
        <el-table-column
          prop="dbValue"
          label="噪音值(dB)"
          width="120"
          :formatter="(row) => row.dbValue.toFixed(1)"
        ></el-table-column>
        <el-table-column
          prop="threshold"
          label="阈值(dB)"
          width="120"
          :formatter="(row) => row.threshold.toFixed(1)"
        ></el-table-column>
        <el-table-column
          prop="overRange"
          label="超标范围(dB)"
          width="120"
          :formatter="(row) => (row.dbValue - row.threshold).toFixed(1)"
        ></el-table-column>
        <el-table-column
          label="操作"
          width="120"
          align="center"
        >
          <template #default="scope">
            <el-button 
              type="text" 
              size="mini" 
              @click="viewEvidence(scope.row)"
              :disabled="!scope.row.evidenceUrl"
            >
              <el-icon><EyeFilled /></el-icon> 查看证据
            </el-button>
          </template>
        </el-table-column>
      </el-table>
    </el-card>
  </div>
</template>

<script setup>
import { ref, onMounted, onUnmounted, watch } from 'vue';
import { ElMessage, ElMessageBox } from 'element-plus';
import { SoundFilled, CalendarFilled, ClockFilled, Download, EyeFilled } from '@element-plus/icons-vue';
import { getCurrentNoiseStatus, getNoiseRecords, exportNoiseOverRecords } from '@/api/noiseMonitorApi';
import { formatDate } from '@/utils/dateUtils';
import Chart from 'chart.js/auto';

// 响应式数据定义
const currentDb = ref(0.0); // 当前分贝值
const threshold = ref(45.0); // 默认夜间阈值（可从云端动态获取）
const currentStatus = ref('normal'); // 当前状态：normal-正常，danger-超标
const todayOverCount = ref(0); // 今日超标次数
const lastOverTime = ref(''); // 最近超标时间
const timeRange = ref('today'); // 时间范围筛选
const dateRange = ref([]); // 自定义时间范围
const overRecords = ref([]); // 超标记录列表
const loading = ref(false); // 加载状态
const noiseChart = ref(null); // 图表实例
const statusRefreshInterval = ref(null); // 状态刷新定时器

// 页面挂载时初始化
onMounted(() => {
  // 初始化图表
  initNoiseChart();
  // 加载噪音记录
  fetchNoiseRecords();
  // 加载当前噪音状态
  fetchCurrentStatus();
  // 定时刷新当前状态（5秒/次）
  statusRefreshInterval.value = setInterval(fetchCurrentStatus, 5000);
});

// 页面卸载时清理
onUnmounted(() => {
  // 清除定时器
  if (statusRefreshInterval.value) {
    clearInterval(statusRefreshInterval.value);
  }
  // 销毁图表实例
  if (noiseChart.value) {
    noiseChart.value.destroy();
  }
});

// 监听时间范围变化，重新加载数据
watch(timeRange, (newVal) => {
  if (newVal !== 'custom') {
    fetchNoiseRecords();
  }
});

/**
 * 初始化噪音趋势图表
 */
const initNoiseChart = () => {
  const ctx = document.getElementById('noiseTrendChart').getContext('2d');
  // 创建图表实例
  noiseChart.value = new Chart(ctx, {
    type: 'line',
    data: {
      labels: [],
      datasets: [
        {
          label: '噪音值(dB)',
          data: [],
          borderColor: '#409eff',
          backgroundColor: 'rgba(64, 158, 255, 0.1)',
          borderWidth: 2,
          fill: true,
          tension: 0.4,
          pointRadius: 3,
          pointHoverRadius: 5
        },
        {
          label: '阈值(dB)',
          data: [],
          borderColor: '#ff4d4f',
          borderWidth: 1.5,
          borderDash: [5, 5],
          fill: false,
          tension: 0,
          pointRadius: 0
        }
      ]
    },
    options: {
      responsive: true,
      maintainAspectRatio: false,
      scales: {
        x: {
          type: 'time',
          time: {
            unit: 'hour',
            displayFormats: {
              hour: 'MM-DD HH:mm'
            },
            tooltipFormat: 'YYYY-MM-DD HH:mm'
          },
          title: {
            display: true,
            text: '时间'
          }
        },
        y: {
          min: 0,
          max: 80, // 最大分贝值（日常环境噪音上限约70dB）
          title: {
            display: true,
            text: '分贝值(dB)'
          },
          ticks: {
            stepSize: 10
          }
        }
      },
      plugins: {
        tooltip: {
          mode: 'index',
          intersect: false,
          callbacks: {
            label: (context) => {
              const label = context.dataset.label || '';
              const value = context.raw || 0;
              return `${label}: ${value.toFixed(1)}`;
            }
          }
        },
        legend: {
          position: 'top'
        }
      }
    }
  });
};

/**
 * 获取当前噪音状态（从云端接口）
 */
const fetchCurrentStatus = async () => {
  try {
    const res = await getCurrentNoiseStatus({ dormId: '101' }); // 寝室ID（实际从登录信息获取）
    if (res.code === 200) {
      currentDb.value = res.data.currentDb;
      threshold.value = res.data.threshold;
      // 更新当前状态
      currentStatus.value = currentDb.value > threshold.value ? 'danger' : 'normal';
    }
  } catch (err) {
    ElMessage.error('获取当前噪音状态失败：' + (err.message || '网络异常'));
  }
};

/**
 * 获取噪音记录（含趋势数据与超标记录）
 */
const fetchNoiseRecords = async () => {
  loading.value = true;
  try {
    // 构造查询参数
    const params = {
      dormId: '101', // 寝室ID（实际从登录信息获取）
      timeRange: timeRange.value
    };
    // 自定义时间范围补充参数
    if (timeRange.value === 'custom' && dateRange.value.length === 2) {
      params.startTime = dateRange.value[0].toISOString();
      params.endTime = dateRange.value[1].toISOString();
    }

    const res = await getNoiseRecords(params);
    if (res.code === 200) {
      const { trendData, overRecords: overList, todayOverCount: count, lastOverTime: lastTime } = res.data;
      
      // 更新超标统计
      todayOverCount.value = count;
      lastOverTime.value = lastTime ? formatDate(lastTime, 'MM-DD HH:mm') : '';
      
      // 更新超标记录列表
      overRecords.value = overList;
      
      // 更新图表数据
      if (noiseChart.value && trendData.length > 0) {
        noiseChart.value.data.labels = trendData.map(item => new Date(item.recordTime));
        noiseChart.value.data.datasets[0].data = trendData.map(item => item.dbValue);
        noiseChart.value.data.datasets[1].data = trendData.map(item => item.threshold);
        noiseChart.value.update();
      }
    }
  } catch (err) {
    ElMessage.error('获取噪音记录失败：' + (err.message || '网络异常'));
  } finally {
    loading.value = false;
  }
};

/**
 * 导出超标记录
 */
const exportRecords = async () => {
  try {
    const res = await exportNoiseOverRecords({
      dormId: '101',
      startTime: dateRange.value[0]?.toISOString() || '',
      endTime: dateRange.value[1]?.toISOString() || '',
      timeRange: timeRange.value
    });
    // 处理文件流下载
    const blob = new Blob([res], { type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' });
    const url = URL.createObjectURL(blob);
    const a = document.createElement('a');
    a.href = url;
    a.download = `寝室101噪音超标记录_${formatDate(new Date(), 'YYYYMMDDHHmm')}.xlsx`;
    a.click();
    URL.revokeObjectURL(url);
    ElMessage.success('记录导出成功');
  } catch (err) {
    ElMessage.error('导出记录失败：' + (err.message || '服务器异常'));
  }
};

/**
 * 查看超标证据（图片/音频）
 */
const viewEvidence = (record) => {
  if (!record.evidenceUrl) {
    ElMessage.warning('暂无证据文件');
    return;
  }
  // 打开证据预览弹窗（此处简化处理，实际可集成el-dialog+图片预览组件）
  ElMessageBox({
    title: '超标证据预览',
    message: `<img src="${record.evidenceUrl}" style="width: 100%; max-height: 400px; object-fit: contain;" />`,
    dangerouslyUseHTMLString: true,
    width: '60%',
    buttons: [
      {
        text: '关闭',
        type: 'text',
        handler: (action, instance) => {
          instance.close();
        }
      }
    ]
  });
};

/**
 * 格式化日期时间
 */
const formatDateTime = (row, column) => {
  return row.recordTime ? formatDate(row.recordTime, 'YYYY-MM-DD HH:mm:ss') : '';
};

/**
 * 返回上一页
 */
const handleBack = () => {
  window.history.back();
};
</script>

<style scoped>
.noise-monitor-page {
  padding: 20px;
  background-color: #f5f7fa;
  min-height: calc(100vh - 60px);
}

/* 状态卡片样式 */
.status-card-row {
  margin-bottom: 20px;
}

.status-card {
  height: 100%;
  transition: box-shadow 0.3s;
}

.status-card:hover {
  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.08);
}

.card-header {
  display: flex;
  align-items: center;
  margin-bottom: 15px;
}

.card-icon {
  color: #409eff;
  font-size: 18px;
  margin-right: 8px;
}

.card-title {
  font-size: 16px;
  font-weight: 500;
  color: #303133;
}

.card-content {
  padding-left: 2px;
}
.db-value, .count-value {
  font-size: 28px;
  font-weight: 600;
  color: #1f2329;
  line-height: 1.2;
  margin-bottom: 8px;
}

.unit {
  font-size: 16px;
  color: #606266;
  margin-left: 4px;
}

.status-tag {
  display: flex;
  align-items: center;
  gap: 10px;
}

.threshold {
  font-size: 14px;
  color: #606266;
}

.last-over-time {
  display: flex;
  align-items: center;
  margin-top: 8px;
}

.time-icon {
  font-size: 14px;
  color: #606266;
  margin-right: 4px;
}

.time-text {
  font-size: 14px;
  color: #606266;
}

/* 图表卡片样式 */
.chart-card {
  transition: all 0.3s;
}

.chart-card:hover {
  box-shadow: 0 2px 12px rgba(0, 0, 0, 0.06);
}

.chart-header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  margin-bottom: 15px;
  padding-bottom: 10px;
  border-bottom: 1px solid #f0f0f0;
}

.chart-title {
  font-size: 16px;
  font-weight: 500;
  color: #303133;
}

.filter-group {
  display: flex;
  align-items: center;
}

.chart-container {
  width: 100%;
  height: 300px;
  position: relative;
}

/* 记录表格样式 */
.records-card {
  transition: all 0.3s;
}

.records-card:hover {
  box-shadow: 0 2px 12px rgba(0, 0, 0, 0.06);
}

.records-header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  margin-bottom: 15px;
}

.records-title {
  font-size: 16px;
  font-weight: 500;
  color: #303133;
}

/* 响应式适配 */
@media (max-width: 768px) {
  .noise-monitor-page {
    padding: 10px;
  }
  
  .chart-header {
    flex-direction: column;
    align-items: flex-start;
    gap: 10px;
  }
  
  .filter-group {
    width: 100%;
    flex-direction: column;
    align-items: flex-start;
    gap: 10px;
  }
  
  .el-select, .el-date-picker {
    width: 100% !important;
  }
  
  .records-header {
    flex-direction: column;
    align-items: flex-start;
    gap: 10px;
  }
  
  .db-value, .count-value {
    font-size: 24px;
  }
}

前端界面实现采用组件化设计思想，将噪音监控功能拆解为状态展示、趋势分析、记录管理三个核心组件，通过以下技术特点确保用户体验：

1. 实时性保障：通过 5 秒间隔的定时器刷新当前噪音状态，结合 Chart.js 的动态更新能力，实现数据可视化的近实时展示，让用户及时掌握寝室噪音变化。

2. 数据直观化：采用色彩编码（绿色表示正常、红色表示超标）和数值分级展示，将抽象的分贝数据转化为直观的视觉信号；趋势图表通过双数据集对比（噪音值与阈值），清晰呈现超标时段与程度。

3. 操作轻量化：提供时间范围快速筛选（今日 / 近 7 天 / 近 30 天）与自定义选择，支持超标记录一键导出（Excel 格式），满足向辅导员反馈时的证据整理需求；证据查看功能通过弹窗实现，避免页面跳转带来的操作中断。

4. 响应式设计：通过 Element Plus 的栅格系统与自定义 CSS 媒体查询，确保界面在 PC 端（宿舍电脑）与移动端（手机）均有良好展示效果，适配用户在寝室、教室、外出等多场景下的使用需求。

该界面不仅实现了噪音数据的可视化呈现，更通过 "客观数据展示 - 证据链管理 - 便捷导出" 的功能闭环，为寝室成员提供了非接触式沟通的技术支撑 —— 当奇妙室友再次出现噪音干扰时，用户无需直面冲突，只需通过界面导出的超标记录即可完成有效沟通或维权。

五、系统部署与落地步骤

1. 前期准备（1-2 天）

1. 硬件采购：购买树莓派 4B（带电源、SD 卡）、USB 麦克风、红外人体传感器、USB 摄像头（可选），总成本约 1000 元。
2. 云资源准备：购买阿里云 ECS（2 核 4G，用于部署 K8s 集群）、PolarDB 数据库（1 核 2G，入门版）、MinIO 对象存储（可部署在 ECS 上，无需额外购买），每月成本约 200 元。
3. 室友共识：与另外 2 个正常室友沟通，达成共识（支持系统部署），并与奇妙室友沟通（告知数据采集范围、用途，签署电子确认书，若拒绝，可告知辅导员作为后续调解依据）。

2. 系统部署（3-5 天）

（1）边缘设备部署（树莓派）

1. 安装 Linux 系统（如 Raspbian），配置网络（连接寝室 WiFi）。
2. 编译运行 C++ 高性能服务器（基于 muduo 库），实现噪音采集、分贝计算、传感器数据读取功能。
3. 配置 AES-256 加密参数（密钥从 Nacos 获取），实现数据加密上传逻辑。

（2）云端部署（K8s 集群）

1. 在 ECS 上安装 Docker 与 K8s（使用 kubeadm 部署），配置 Master 节点与 Worker 节点（若 ECS 资源足够，可单节点部署用于测试，生产环境建议 2 个 Worker 节点）。
2. 部署 Nacos（用于服务注册与配置）、MinIO（对象存储）、Redis（缓存），通过 K8s 的 Deployment 与 Service 配置，确保服务高可用。
3. 部署 5 个微服务（record-service、evidence-service 等），每个服务打包为 Docker 镜像，通过 K8s 的 Deployment 部署，配置 HPA 动态扩缩容。

（3）前端部署

1. 编译 Vue 前端项目（执行npm run build），生成静态文件。
2. 将静态文件部署到 Nginx（运行在 K8s 集群中），配置 HTTPS（使用 Let's Encrypt 免费证书），确保前端访问安全。

3. 系统测试与优化（1-2 天）

1. 功能测试：测试噪音采集（播放不同分贝的声音，验证系统记录是否准确）、证据上传（上传图片，验证加密与哈希校验是否生效）、匿名提醒（发送提醒，验证对方是否收到）。
2. 性能测试：模拟 10 个边缘设备同时上传数据，验证系统是否能正常处理（无数据丢失、延迟≤1 秒）。
3. 隐私测试：检查敏感数据（如用户信息）是否加密存储，未授权用户是否无法访问。

4. 日常使用与维护

1. 数据查看：每周查看一次行为记录统计，若违规次数较多，可导出记录找辅导员调解。
2. 设备维护：定期检查树莓派与传感器（如麦克风是否正常、传感器是否松动），确保数据采集正常。
3. 规则更新：若寝室作息变化（如考试周需要更早休息），管理员可发起规则修改，经≥2 个室友确认后生效。

六、预期效果与扩展场景

1. 核心预期效果

• 冲突规避：通过客观数据记录与非接触式提醒，减少直接争吵，低素质室友的违规行为将从 “无感知”“不承认” 转向 “可量化”“有约束”。例如，当系统第 3 次自动推送 “夜间 11 点后分贝超 50dB” 的提醒时，即使对方不愿直面问题，也会在重复的客观数据提示下收敛行为；同时，另外 2 名室友无需再 “当面指责”，避免激化矛盾，实现 “用数据说话，而非用情绪对抗”。
• 证据闭环：针对 “屡教不改” 的核心痛点，系统将形成 “行为记录 - 证据文件 - 沟通痕迹” 的完整证据链。若后续需向辅导员、宿管反馈，可直接导出包含时间戳、加密哈希值、图片 / 音频证据的报告（如 “2024 年 10 月 1 日 - 10 月 7 日，该室友夜间违规噪音记录 5 次，阳台占用超规定区域时长累计 12 小时，已发送匿名提醒 3 次”），彻底摆脱 “口头描述无凭证” 的困境，让维权更具说服力。
• 隐私保护与公平性：通过 AES 加密用户敏感信息、SHA-256 防数据篡改、匿名沟通机制，既避免 “记录行为” 异化为 “恶意监控”，也防止某一方滥用系统权限（如篡改记录、泄露他人隐私）。例如，普通室友仅能查看违规记录的 “事实数据”（时间、分贝值、证据图片），无法知晓 “谁提交的记录”；管理员权限需经 2 人以上确认，确保规则制定、数据导出的公平性。
• 空间与卫生改善：针对 “阳台占用”“乱扔垃圾” 等问题，系统通过红外传感器记录区域占用时长、图片证据标记卫生死角，形成 “违规次数 - 整改要求” 的关联机制。例如，当某室友阳台占用超规定区域（如 1/4）累计 3 天，系统自动推送 “需在 24 小时内整理个人物品” 的提醒，若逾期未整改，可触发 “集体反馈辅导员” 的流程，倒逼其维护公共空间秩序。
• 情绪减负：对性格偏温和、不愿冲突的用户（如你提到 “听过最多评价是温柔”），系统将替代 “忍气吞声” 或 “被迫对抗” 的被动状态 —— 无需再因 “对方摔门、唱歌” 而焦虑，无需纠结 “要不要提醒”，只需通过手机端一键上传证据、触发自动提醒，将精力从 “应对傻逼室友” 转移到学习（如你提到的 “复习”）、生活上，实现 “情绪内耗最小化”。

2. 扩展场景：从 “寝室管理” 到 “校园生活协同”

系统并非仅局限于解决 “低素质室友” 问题，基于现有技术架构，可横向扩展至更多校园场景，提升整体使用价值：

（1）多寝室协同：构建 “楼层 / 楼栋规则联盟”

当同楼层多个寝室均存在类似 “噪音扰民”“卫生脏乱” 问题时，可通过系统的 “规则联盟” 功能，由多个寝室共同制定 “楼层公共规则”（如 “晚 11 点后禁止走廊喧哗”“垃圾需分类投放至楼下垃圾桶”）。此时，系统将升级为 “楼层级管理平台”：

• 感知层：在楼层走廊、公共卫生间安装共享传感器（如噪音检测仪、垃圾桶满溢传感器），数据由所有联盟寝室共同查看；
• 业务层：新增 “楼层违规公示” 模块，对多次违反公共规则的寝室（需经 3 个以上联盟寝室确认），在楼层公示栏（线上）发布提醒，形成 “集体约束” 压力；
• 权限层：新增 “楼层管理员” 角色（由各寝室轮流担任），负责统筹规则制定与违规协调，避免单个寝室 “孤立维权”。

（2）跨场景适配：延伸至 “班级 / 社团共享空间”

除寝室外，系统可快速适配班级自习室、社团活动室等共享空间，解决 “物品乱堆”“使用冲突” 等问题：

• 空间预约：通过 Vue 前端新增 “共享空间预约模块”，用户可预约自习室使用时段（如 “周三晚 7-9 点”），系统自动记录预约人、使用时长，避免 “占座不使用”；
• 物品管理：对共享物品（如社团活动器材、自习室公共插座），通过 NFC 标签关联系统，使用时需在 APP 上 “扫码登记”，归还时标记 “状态（完好 / 损坏）”，防止物品丢失或损坏后无人负责；
• 卫生追溯：在共享空间安装摄像头（仅拍摄公共区域，不拍摄人脸），若出现 “乱扔垃圾” 等问题，可通过系统回溯对应时间段的图片证据，快速定位责任人（需经管理员授权查看）。

（3）对接校园管理：打通 “宿管 / 辅导员协同通道”

当系统记录的违规行为超出 “寝室内部协调” 范围（如 “长期占用他人床铺”“乱扔带病菌垃圾”），可通过 API 接口对接学校 “宿管管理系统”“辅导员办公系统”，实现 “数据同步 - 协同处理”：

• 自动上报：当某室友违规次数累计超 5 次，且经 3 次提醒仍未整改时，系统自动向对应辅导员推送 “违规报告”（含完整证据链），无需人工手动提交；
• 处理跟踪：辅导员接收报告后，可在系统中标记 “处理状态（待沟通 / 已约谈 / 已整改）”，寝室成员可实时查看处理进度，避免 “反馈后石沉大海”；
• 数据归档：所有处理记录（约谈记录、整改承诺书）均通过 SHA-256 哈希存储在系统中，作为学生综合素质评价、宿舍评优的参考依据，形成 “管理闭环”。

3. 技术扩展：持续提升系统能力边界

基于现有云原生架构，可通过技术迭代进一步强化系统性能与安全性，适配更复杂场景：

（1）AI 行为识别：从 “被动记录” 到 “主动预判”

引入 AI 视觉识别技术（如基于 TensorFlow Lite 部署在树莓派端），实现对 “违规行为” 的主动识别与预判：

• 行为识别：通过摄像头实时识别 “乱扔垃圾”“占用他人床铺” 等行为，无需人工上传证据，系统自动抓拍图片并生成记录（如 “识别到 2024-10-09 16:30，某成员将外卖盒扔在公共桌面，已生成证据”）；
• 趋势预判：基于历史违规数据，通过机器学习模型（如 LSTM）预判某室友的违规趋势，例如 “近 7 天夜间噪音违规次数递增，未来 3 天大概率继续违规”，提前推送 “预防性提醒”（如 “近期夜间休息受影响较多，建议调整作息或降低活动音量”）。

（2）边缘计算升级：从 “单设备采集” 到 “多设备协同”

将原有的 “单树莓派采集” 升级为 “多边缘设备协同网络”，提升数据采集的覆盖范围与准确性：

• 设备联动：在寝室 4 个角落各部署 1 个微型传感器（如 ESP32 开发板，成本更低），同步采集噪音、光线数据，通过边缘节点间的本地通信（如蓝牙 Mesh）汇总数据，避免 “单设备采集存在盲区”（如靠近门的传感器未捕捉到阳台的噪音）；
• 低功耗优化：采用 “休眠 - 唤醒” 机制，当传感器检测到环境无变化（如白天无人在寝室）时自动进入休眠模式，降低功耗，延长设备续航（如从原有的 24 小时续航提升至 72 小时）。

（3）区块链存证：从 “中心式存储” 到 “不可篡改存证”

针对 “证据法律效力” 的更高需求，可引入区块链技术（如基于 FISCO BCOS 联盟链），将核心证据数据（如违规记录哈希值、证据文件签名）上链存储：

• 上链流程：当系统生成一条违规记录时，同步计算该记录的 SHA-256 哈希值，发送至联盟链节点（由学校、宿管中心、辅导员办公室共同作为节点），生成不可篡改的区块链存证；
• 司法认可：若后续出现更严重的冲突（如涉及人身安全、财产损失），可通过区块链存证向学校保卫处、甚至司法机关提供证据，其 “不可篡改” 特性将提升证据的法律效力，远超传统的本地存储记录。

七、总结：技术的本质是 “工具，而非武器”

通过这套系统的设计，最终想实现的并非 “忍受”，而是 “摆脱被动”：用客观数据替代主观情绪，用规则约束替代无意义对抗，用证据留存替代口头扯皮。

需要明确的是，技术无法直接 “改变奇妙室友的性格”，但能为你和室友构建一道 “情绪保护盾” 与 “维权支撑墙”：当对方摔门、唱歌、占用空间时，你无需再纠结 “要不要忍”“要不要吵”，只需让系统记录事实；当需要向辅导员反馈时，你无需再 “翻遍聊天记录找证据”，只需导出系统生成的报告。

最终，这套基于 Vue、SpringCloud、加密算法构建的系统，本质是将 “寝室矛盾” 从 “人与人的情绪对抗” 转化为 “人与规则的数据协同”，让你能把更多精力放在学习、生活上 —— 毕竟，比起纠结 “如何忍受奇妙物种”，让自己的大学生活更有价值，才是更重要的事。