基于 Spring Boot 的学生成绩综合统计分析系统设计

Score.java（成绩实体）

package com.example.edu.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
import java.time.LocalDate;

/**
 * 成绩实体类：映射 score 表
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("score")
public class Score {
    /**
     * 成绩 ID：主键，自增
     */
    @TableId(type = IdType.AUTO)
    private Long id;

    /**
     * 关联学号：外键，关联 student 表的 studentNo
     */
    private Long studentNo;

    /**
     * 课程编码：关联 course 表的 courseCode
     */
    private String courseCode;

    /**
     * 分数：保留 2 位小数，范围 0-100
     */
    private BigDecimal score;

    /**
     * 考试时间：如 2024-06-20
     */
    private LocalDate examDate;

    /**
     * 考试类型：期中/期末/月考
     */
    private String examType;
}

dto 包下数据传输对象示例

ScoreAddDTO.java（成绩录入请求 DTO）

package com.example.edu.dto;

import jakarta.validation.constraints.DecimalMax;
import jakarta.validation.constraints.DecimalMin;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import java.math.BigDecimal;
import java.time.LocalDate;

/**
 * 成绩录入请求 DTO：接收前端传入的成绩数据，含参数校验
 */
@Data
public class ScoreAddDTO {
    /**
     * 关联学号：必填
     */
    @NotNull(message = "学号不能为空")
    private Long studentNo;

    /**
     * 课程编码：必填
     */
    @NotBlank(message = "课程编码不能为空")
    private String courseCode;

    /**
     * 分数：必填，0-100 分
     */
    @NotNull(message = "分数不能为空")
    @DecimalMin(value = "0.00", message = "分数不能低于 0 分")
    @DecimalMax(value = "100.00", message = "分数不能高于 100 分")
    private BigDecimal score;

    /**
     * 考试时间：必填
     */
    @NotNull(message = "考试时间不能为空")
    private LocalDate examDate;

    /**
     * 考试类型：必填，只能是期中/期末/月考
     */
    @NotBlank(message = "考试类型不能为空")
    private String examType;
}

StudentRankQueryDTO.java（个人排名查询 DTO）

package com.example.edu.dto;

import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import lombok.Data;

/**
 * 个人排名查询 DTO：接收前端查询参数
 */
@Data
public class StudentRankQueryDTO {
    /**
     * 学号：必填
     */
    @NotNull(message = "学号不能为空")
    private Long studentNo;

    /**
     * 课程编码：必填
     */
    @NotBlank(message = "课程编码不能为空")
    private String courseCode;

    /**
     * 学期：必填，格式如 2024-2025-1
     */
    @NotBlank(message = "学期不能为空")
    private String term;
}

vo 包下视图对象示例

StudentRankVO.java（个人排名返回 VO）

package com.example.edu.vo;

import lombok.Data;
import java.math.BigDecimal;

/**
 * 个人排名返回 VO：封装前端需要的排名数据，隐藏数据库字段细节
 */
@Data
public class StudentRankVO {
    /**
     * 学号
     */
    private Long studentNo;

    /**
     * 学生姓名
     */
    private String studentName;

    /**
     * 课程名称
     */
    private String courseName;

    /**
     * 分数
     */
    private BigDecimal score;

    /**
     * 年级排名
     */
    private Integer rank;

    /**
     * 年级总人数
     */
    private Integer gradeTotal;

    /**
     * 排名百分比：如 30.50%
     */
    private String rankPercentage;
}

mapper 包下数据访问接口示例

ScoreMapper.java

package com.example.edu.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.edu.entity.Score;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import java.util.List;

/**
 * 成绩 Mapper 接口：继承 MyBatis-Plus 的 BaseMapper，自带 CRUD 方法
 */
@Mapper
public interface ScoreMapper extends BaseMapper<Score> {
    /**
     * 自定义查询：按班级、课程、学期查询成绩列表
     */
    @Select("SELECT * FROM score s JOIN student st ON s.student_no = st.student_no " +
            "WHERE st.class_id = #{classId} AND s.course_code = #{courseCode} AND s.term = #{term}")
    List<Score> selectByClassAndCourse(String classId, String courseCode, String term);

    /**
     * 自定义查询：统计年级内某课程分数高于目标分数的人数
     */
    @Select("SELECT COUNT(*) FROM score WHERE course_code = #{courseCode} AND term = #{term} AND score > #{targetScore}")
    Long countHigherScore(String courseCode, String term, BigDecimal targetScore);
}

service 包下接口及实现类示例

ScoreService.java（成绩服务接口）

package com.example.edu.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.example.edu.dto.ScoreAddDTO;
import com.example.edu.dto.StudentRankQueryDTO;
import com.example.edu.entity.Score;
import com.example.edu.vo.ScoreDistributionVO;
import com.example.edu.vo.StudentRankVO;

/**
 * 成绩服务接口：定义成绩相关业务逻辑
 */
public interface ScoreService extends IService<Score> {
    /**
     * 录入成绩
     * @param scoreAddDTO 成绩录入参数
     * @return 录入成功的成绩实体
     */
    Score addScore(ScoreAddDTO scoreAddDTO);

    /**
     * 查询个人年级排名
     * @param queryDTO 排名查询参数
     * @return 个人排名信息 VO
     */
    StudentRankVO getStudentGradeRank(StudentRankQueryDTO queryDTO);

    /**
     * 统计班级成绩分布（按分数段）
     * @param classId 班级 ID
     * @param courseCode 课程编码
     * @param term 学期
     * @return 成绩分布 VO
     */
    ScoreDistributionVO getClassScoreDistribution(String classId, String courseCode, String term);
}

ScoreServiceImpl.java（成绩服务实现类）

package com.example.edu.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.edu.dto.ScoreAddDTO;
import com.example.edu.dto.StudentRankQueryDTO;
import com.example.edu.entity.Course;
import com.example.edu.entity.Score;
import com.example.edu.entity.Student;
import com.example.edu.mapper.CourseMapper;
import com.example.edu.mapper.ScoreMapper;
import com.example.edu.mapper.StudentMapper;
import com.example.edu.service.ScoreService;
import com.example.edu.vo.ScoreDistributionVO;
import com.example.edu.vo.StudentRankVO;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 成绩服务实现类：实现成绩相关业务逻辑
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class ScoreServiceImpl extends ServiceImpl<ScoreMapper, Score> implements ScoreService {
    private final ScoreMapper scoreMapper;
    private final StudentMapper studentMapper;
    private final CourseMapper courseMapper;

    @Override
    @Transactional // 事务控制：确保成绩录入失败时回滚
    public Score addScore(ScoreAddDTO scoreAddDTO) {
        log.info("开始录入成绩：学号={}, 课程编码={}", scoreAddDTO.getStudentNo(), scoreAddDTO.getCourseCode());
        
        // 1. 校验学生与课程是否存在
        Student student = studentMapper.selectById(scoreAddDTO.getStudentNo());
        Course course = courseMapper.selectById(scoreAddDTO.getCourseCode());
        if (student == null) {
            throw new RuntimeException("学号不存在：" + scoreAddDTO.getStudentNo());
        }
        if (course == null) {
            throw new RuntimeException("课程编码不存在：" + scoreAddDTO.getCourseCode());
        }

        // 2. 转换 DTO 为实体
        Score score = new Score();
        BeanUtils.copyProperties(scoreAddDTO, score);
        
        // 补充学期（从考试时间推导，如 2024-06 属于 2023-2024-2 学期）
        String term = getTermByExamDate(scoreAddDTO.getExamDate());
        score.setTerm(term);

        // 3. 保存成绩
        save(score);
        log.info("成绩录入成功：成绩 ID={}", score.getId());
        return score;
    }

    @Override
    public StudentRankVO getStudentGradeRank(StudentRankQueryDTO queryDTO) {
        log.info("查询个人排名：学号={}, 课程编码={}, 学期={}", queryDTO.getStudentNo(), queryDTO.getCourseCode(), queryDTO.getTerm());
        
        // 1. 查询学生、课程与成绩信息
        Student student = studentMapper.selectById(queryDTO.getStudentNo());
        Course course = courseMapper.selectById(queryDTO.getCourseCode());
        Score score = lambdaQuery()
                .eq(Score::getStudentNo, queryDTO.getStudentNo())
                .eq(Score::getCourseCode, queryDTO.getCourseCode())
                .eq(Score::getTerm, queryDTO.getTerm())
                .one();
        if (score == null) {
            throw new RuntimeException("未查询到该学生的成绩记录");
        }

        // 2. 统计排名（高于当前分数的人数 +1）
        Long higherCount = scoreMapper.countHigherScore(
                queryDTO.getCourseCode(), 
                queryDTO.getTerm(), 
                score.getScore());
        Integer rank = higherCount.intValue() + 1;

        // 3. 统计年级总人数
        Integer gradeTotal = lambdaQuery()
                .eq(Score::getCourseCode, queryDTO.getCourseCode())
                .eq(Score::getTerm, queryDTO.getTerm())
                .list()
                .size();

        // 4. 封装 VO 返回
        StudentRankVO rankVO = new StudentRankVO();
        rankVO.setStudentNo(student.getStudentNo());
        rankVO.setStudentName(student.getStudentName());
        rankVO.setCourseName(course.getCourseName());
        rankVO.setScore(score.getScore());
        rankVO.setRank(rank);
        rankVO.setGradeTotal(gradeTotal);
        
        // 计算排名百分比（保留 2 位小数）
        String rankPercentage = String.format("%.2f%%", (double) rank / gradeTotal * 100);
        rankVO.setRankPercentage(rankPercentage);
        return rankVO;
    }

    @Override
    public ScoreDistributionVO getClassScoreDistribution(String classId, String courseCode, String term) {
        // 1. 查询班级成绩列表
        List<Score> scoreList = scoreMapper.selectByClassAndCourse(classId, courseCode, term);

        // 2. 按分数段分组统计
        Map<String, Long> distributionMap = scoreList.stream().collect(Collectors.groupingBy(
                s -> {
                    double scoreValue = s.getScore().doubleValue();
                    if (scoreValue < 60) return "0-59";
                    else if (scoreValue < 70) return "60-69";
                    else if (scoreValue < 80) return "70-79";
                    else if (scoreValue < 90) return "80-89";
                    else return "90-100";
                },
                Collectors.counting()
        ));

        // 3. 封装 VO
        ScoreDistributionVO distributionVO = new ScoreDistributionVO();
        distributionVO.setClassId(classId);
        distributionVO.setCourseCode(courseCode);
        distributionVO.setTerm(term);
        distributionVO.setSegment0_59(distributionMap.getOrDefault("0-59", 0L));
        distributionVO.setSegment60_69(distributionMap.getOrDefault("60-69", 0L));
        distributionVO.setSegment70_79(distributionMap.getOrDefault("70-79", 0L));
        distributionVO.setSegment80_89(distributionMap.getOrDefault("80-89", 0L));
        distributionVO.setSegment90_100(distributionMap.getOrDefault("90-100", 0L));
        return distributionVO;
    }

    /**
     * 辅助方法：根据考试时间推导学期
     */
    private String getTermByExamDate(java.time.LocalDate examDate) {
        int year = examDate.getYear();
        int month = examDate.getMonthValue();
        if (month >= 9 && month <= 12) {
            return year + "-" + (year + 1) + "-1"; // 9-12 月属于下学年第一学期
        } else {
            return (year - 1) + "-" + year + "-2"; // 1-8 月属于本学年第二学期
        }
    }
}

3. 网页展示

系统前端集成了可视化看板，登录后即可查看详细的数据概览。包括班级成绩分布直方图、个人成绩趋势折线图以及实时排名更新。界面设计遵循简洁原则，确保教师与学生能快速定位关键信息。

四、自我感想

在开发在线学生成绩综合统计分析系统的过程中，我对'教育信息化'的理解从单纯的技术落地转向了业务适配。最初仅关注成绩的增删改查，后来发现教师更需要'成绩波动预警'来定位待辅导学生，学生需要'薄弱学科标注'来明确学习方向——这让我意识到，技术开发必须围绕用户实际需求展开。

技术层面，AI 辅助编码平台大幅降低了重复编码工作量，原本需要数小时编写的 Entity、Mapper 层代码，现在可快速生成，让我有更多精力投入到业务逻辑优化（如排名算法、缓存策略）。同时，通过解决'数据重复导入''可视化加载慢'等问题，我对数据库索引优化、Redis 缓存使用的理解也更加深入，不再是单纯'会用'，而是'能用好'。

这次开发也让我明白，一个合格的系统不仅要'功能能用'，更要'体验好用'——比如为成绩录入添加参数校验，避免教师输入错误分数；为统计报表提供多格式导出，方便管理员汇报使用。这些细节虽小，却直接影响用户对系统的认可程度。

总结

本次在线学生成绩综合统计分析系统的设计与实现，完整覆盖了'需求分析→环境搭建→模块开发→问题优化'的全流程，成功构建了支持多角色、多维度分析的成绩管理系统。系统的核心价值在于：通过 AI 辅助提升开发效率，通过可视化分析挖掘成绩数据价值，通过权限控制保障数据安全，切实解决了传统成绩管理的痛点。

后续，计划进一步扩展系统功能：一是添加 AI 成绩预测模块，基于历史数据预测学生期末成绩；二是对接区域教育大数据平台，实现跨学校成绩对比分析。