Java源码社

基于javaweb的SpringBoot作业管理系统(java+springboot+mybaits+vue+elementui+mysql)

更新于

运行环境

Java≥8、MySQL≥5.7、Node.js≥14

开发工具

后端：eclipse/idea/myeclipse/sts等均可配置运行
前端：WebStorm/VSCode/HBuilderX等均可

❗没学过node.js的不要搞前后端分离项目

适用

课程设计，大作业，毕业设计，项目练习，学习演示等

功能说明

102225592508

112225592508

122225592508

132225592508

142225592508

152225592508

162225592508

172225592508

基于javaweb的SpringBoot作业管理系统(java+springboot+mybaits+vue+elementui+mysql)

环境需要

1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。

2.IDE环境：IDEA，Eclipse,Myeclipse都可以。推荐IDEA;

3.硬件环境：windows 7/8/10 1G内存以上；或者 Mac OS； 

4.数据库：MySql 5.7/8.0版本均可；

5.是否Maven项目：是；

技术栈

后端：SpringBoot+Mybaits

前端：Vue + elementui

使用说明

项目运行：

  1. 使用Navicat或者其它工具，在mysql中创建对应sql文件名称的数据库，并导入项目的sql文件；

  2. 使用IDEA/Eclipse/MyEclipse导入项目，导入成功后请执行maven clean;maven install命令；

  3. 将项目中application.yml配置文件中的数据库配置改为自己的配置;

  4. 运行项目，在浏览器中输入地址：

前台地址：http://localhost:8080/springbootrpj39/front/index.html

后台地址：http://localhost:8080/springbootrpj39/admin/dist/index.html

管理员 abo 密码 abo

用户：用户1 密码： 123456

注意项目文件路径中不能含有中文、空格、特殊字符等，否则图片会上传不成功。

老师管理控制层：

/**

  • Title: TeacherInfoHandler

  • Description: 教师

*/

@Controller

@SuppressWarnings(“all”)

public class TeacherInfoHandler {

@Autowired

private TeacherInfoService teacherInfoService;

private Logger logger = Logger.getLogger(TeacherInfoHandler.class);

/**

  • 获取 验证教师信息

  • @param teacherAccount

  • @param response

  • @throws Exception

*/

@RequestMapping(value = “/validateTeacher”, method = RequestMethod.POST)

public void queryTeacherExists(@RequestParam(value = “account”) String teacherAccount, HttpServletResponse response)

throws Exception {

logger.info(“获取教师 “ + teacherAccount + “ 的信息”);

TeacherInfo teacherInfo = null;

teacherInfo = teacherInfoService.getTeacherByAccount(teacherAccount);

// 教师账户不存在

if (teacherInfo == null) {

response.getWriter().print(“1”);

} else {

response.getWriter().print(teacherInfo.getTeacherPwd());

/**

  • 教师登录

  • @param teacherAccount

  • @param request

  • @return

*/

@RequestMapping(value = “/teacherlogin”, method = RequestMethod.POST)

public String teacherLogin(@RequestParam(“teacherAccount”) String teacherAccount, HttpServletRequest request) {

if (teacherAccount == null || “”.equals(teacherAccount)) {

logger.error(“教师账号为空”);

request.setAttribute(“error”, “登录信息有误”);

return “/error”;

logger.info(“教师 “ + teacherAccount + “ 登录”);

// 获取当前登录教师

TeacherInfo teacherInfo = teacherInfoService.getTeacherByAccount(teacherAccount);

if (teacherInfo == null) {

logger.error(“教师账号为空”);

request.setAttribute(“error”, “账号不存在！”);

return “/error”;

String teacherPwd = request.getParameter(“teacherPwd”);

if (!teacherInfo.getTeacherPwd().equals(teacherPwd)) {

logger.error(“密码错误”);

request.setAttribute(“error”, “密码错误！”);

return “/error”;

// 将当前登录教师 后台权限存入 Session

request.getSession().setAttribute(“adminPower”, teacherInfo.getAdminPower());

request.getSession().setAttribute(“loginTeacher”, teacherInfo);

return “redirect:admin/index.jsp”;

/**

  • 教师查看自己的信息

  • @param teacherId

  • @return

*/

@RequestMapping(“/selfinfo/{teacherId}”)

public ModelAndView loginTeacherSelf(@PathVariable(“teacherId”) Integer teacherId) {

ModelAndView model = new ModelAndView();

logger.error(“教师 “ + teacherId + “ 查看自己的信息”);

if (teacherId == null) {

model.setViewName(“../error”);

return model;

} else {

List teachers = new ArrayList();

TeacherInfo teacher = teacherInfoService.getTeacherById(teacherId);

teachers.add(teacher);

model.addObject(“teachers”, teachers);

model.setViewName(“/admin/teacher/teachers”);

return model;

/**

  • 教师退出登录

  • @throws IOException

*/

@RequestMapping(“/exitTeacher”)

public void exitTeacher(HttpSession session, HttpServletResponse response) throws IOException {

session.removeAttribute(“loginTeacher”);

session.removeAttribute(“adminPower”);

response.sendRedirect(“admin/login.jsp”);

/**

  • 查询教师集合

  • @param startPage

  • @param pageShow

  • @return

*/

@RequestMapping(value = “/teachers”, method = RequestMethod.GET)

public ModelAndView getTeachers(

@RequestParam(value = “startPage”, required = false, defaultValue = “1”) Integer startPage, // 当前页码,默认第一页

@RequestParam(value = “pageShow”, required = false, defaultValue = “10”) Integer pageShow /*

  • 每页显示数据量

  • ，

  • 默认10条

*/) {

logger.info(“查询教师集合”);

ModelAndView model = new ModelAndView();

model.setViewName(“admin/teacher/teachers”);

List teachers;

Map<String, Object> map = new HashMap<String, Object>();

// 计算当前查询起始数据索引

int startIndex = (startPage - 1) * pageShow;

map.put(“startIndex”, startIndex);

map.put(“pageShow”, pageShow);

map.put(“teacher”, null);

teachers = teacherInfoService.getTeachers(map);

model.addObject(“teachers”, teachers);

// 获取教师总量

int teacherTotal = teacherInfoService.getTeacherTotal();

// 计算总页数

int pageTotal = 1;

if (teacherTotal % pageShow == 0)

pageTotal = teacherTotal / pageShow;

else

pageTotal = teacherTotal / pageShow + 1;

model.addObject(“pageTotal”, pageTotal);

model.addObject(“pageNow”, startPage);

return model;

/**

  • 预修改教师

  • @param teacherId

  • @return

*/

@RequestMapping(value = “/teacher/{teacherId}”, method = RequestMethod.GET)

public ModelAndView preUpdateTeacher(@PathVariable(“teacherId”) Integer teacherId) {

logger.info(“预修改教师处理”);

ModelAndView model = new ModelAndView();

// 获取要修改教师

TeacherInfo teacher = teacherInfoService.getTeacherById(teacherId);

model.setViewName(“/admin/teacher/teacheredit”);

model.addObject(“teacher”, teacher);

return model;

/**

  • 修改/添加 教师

  • @param teacherId

  • @param isUpdate

  •        操作标识

  • @param teacherName

  • @param teacherAccount

  • @param teacherPwd

  • @param adminPower

  • @return

*/

@RequestMapping(value = “/teacher/teacher”, method = RequestMethod.POST)

public String isUpdateOrAddTeacher(@RequestParam(value = “teacherId”, required = false) Integer teacherId,

@RequestParam(value = “isupdate”, required = false) Integer isUpdate,

@RequestParam(“teacherName”) String teacherName, @RequestParam(“teacherAccount”) String teacherAccount,

@RequestParam(“teacherPwd”) String teacherPwd, @RequestParam(“adminPower”) Integer adminPower) {

TeacherInfo teacher = new TeacherInfo();

teacher.setTeacherId(teacherId);

teacher.setTeacherName(teacherName);

teacher.setTeacherAccount(teacherAccount);

teacher.setTeacherPwd(teacherPwd);

teacher.setAdminPower(adminPower);

if (isUpdate != null) { // 修改

logger.info(“修改教师 “ + teacher + “ 的信息”);

int row = teacherInfoService.isUpdateTeacherInfo(teacher);

} else { // 添加

logger.info(“添加教师 “ + teacher + “ 的信息”);

int row = teacherInfoService.isAddTeacherInfo(teacher);

return “redirect:/teachers”;

/**

  • 删除教师

  • @param teacherId

  • @return

*/

@RequestMapping(value = “/teacher/{teacherId}”, method = RequestMethod.DELETE)

public String isDelTeacher(@PathVariable(“teacherId”) Integer teacherId) {

logger.info(“删除教师 “ + teacherId);

int row = teacherInfoService.isDelTeacherInfo(teacherId);

return “redirect:/teachers”;

学生管理控制层：

@Controller

@SuppressWarnings(“all”)

public class StudentInfoHandler {

@Autowired

private StudentInfoService studentInfoService;

@Autowired

private ClassInfoService classInfoService;

@Autowired

private ExamSubjectMiddleInfoService examSubjectMiddleInfoService;

@Autowired

private ExamHistoryPaperService examHistoryPaperService;

@Autowired

private ExamChooseInfoService examChooseInfoService;

@Autowired

private ExamSubjectMiddleInfo esm;

@Autowired

private ClassInfo classInfo;

@Autowired

private ExamPaperInfo examPaper;

@Autowired

private GradeInfo grade;

@Autowired

private StudentInfo student;

@Autowired

private ExamPaperInfoService examPaperInfoService;

private Logger logger = Logger.getLogger(StudentInfoHandler.class);

/**

  • 获取学生集合

  • @param studentId 学生编号

  • @param classId 班级编号

  • @param gradeId 系部编号

  • @param startPage 起始页 default=1

  • @param pageShow 页容量 default=10

  • @return

*/

@RequestMapping(“/students”)

public ModelAndView getCourses(@RequestParam(value = “studentId”, required = false) Integer studentId,

@RequestParam(value = “classId”, required = false) Integer classId,

@RequestParam(value = “gradeId”, required = false) Integer gradeId,

@RequestParam(value=”startPage”, required=false, defaultValue=”1”) Integer startPage,

@RequestParam(value=”pageShow”, required=false, defaultValue=”10”) Integer pageShow ) {

logger.info(“获取学生集合 classId=”+classId+”, gradeId=”+gradeId+”, startPage=”+startPage+”, pageShow=”+pageShow);

ModelAndView model = new ModelAndView();

model.setViewName(“/admin/student/students”);

//查询条件处理

StudentInfo student = new StudentInfo();

if (studentId != null)

student.setStudentId(studentId);

if (classId != null) {

classInfo.setClassId(classId);

student.setClassInfo(classInfo);

if (gradeId != null) {

grade.setGradeId(gradeId);

student.setGrade(grade);

Map<String, Object> map = new HashMap<String, Object>();

//计算当前查询起始数据索引

int startIndex = (startPage-1) * pageShow;

map.put(“student”, student);

map.put(“startIndex”, startIndex);

map.put(“pageShow”, pageShow);

List students = studentInfoService.getStudents(map);

model.addObject(“students”, students);

//获取学生总量

int studentTotal = studentInfoService.getStudentTotal();

//计算总页数

int pageTotal = 1;

if (studentTotal % pageShow == 0)

pageTotal = studentTotal / pageShow;

else

pageTotal = studentTotal / pageShow + 1;

model.addObject(“pageTotal”, pageTotal);

model.addObject(“pageNow”, startPage);

return model;

/**

  • 根据编号获取学生信息

  • @param studentId

  • @return

*/

@RequestMapping(“/student/{studentId}”)

public ModelAndView getCourseById(@PathVariable(“studentId”) Integer studentId) {

logger.info(“获取学生 “ + studentId);

ModelAndView model = new ModelAndView();

model.setViewName(“/admin/student/studentedit”);

StudentInfo student = studentInfoService.getStudentById(studentId);

model.addObject(“student”, student);

List classes = classInfoService.getClasses(null);

model.addObject(“classes”, classes);

return model;

/**

  • 添加/修改学生信息

  • @param studentId

  • @param isUpdate 操作标识

  • @param studentName

  • @param studentAccount

  • @param studentPwd

  • @param classId

  • @return

*/

@RequestMapping(value = “/student/student”, method = RequestMethod.POST)

public String isUpdateOrAddCourse(

@RequestParam(value = “studentId”, required = false) Integer studentId,

@RequestParam(value = “isupdate”, required = false) Integer isUpdate,

@RequestParam(value = “studentName”, required = false) String studentName,

@RequestParam(“studentAccount”) String studentAccount,

@RequestParam(“studentPwd”) String studentPwd,

@RequestParam(“classId”) Integer classId) {

StudentInfo student = new StudentInfo();

student.setStudentId(studentId);

student.setStudentName(studentName);

student.setStudentAccount(studentAccount);

student.setStudentPwd(studentPwd);

classInfo.setClassId(classId);

student.setClassInfo(classInfo);

if (isUpdate != null) {

logger.info(“修改学生 “ + student + “ 的信息”);

int row = studentInfoService.isUpdateStudent(student);

} else {

logger.info(“添加学生 “ + student + “ 的信息”);

int row = studentInfoService.isAddStudent(student);

return “redirect:/students”;

/**

  • 删除学生

  • @param studentId

  • @return

*/

@RequestMapping(value = “/student/{studentId}”, method = RequestMethod.DELETE)

public String isDelTeacher(@PathVariable(“studentId”) Integer studentId) {

logger.info(“删除学生 “ + studentId);

int row = studentInfoService.isDelStudent(studentId);

return “redirect:/students”;

/**

  • 预添加学生

  • @return

*/

@RequestMapping(“/preAddStudent”)

public ModelAndView preAddStudent() {

logger.info(“预添加学生信息”);

ModelAndView model = new ModelAndView();

model.setViewName(“/admin/student/studentedit”);

List classes = classInfoService.getClasses(null);

model.addObject(“classes”, classes);

return model;

/**

  • 学生考试登录验证

  • 此处验证并不合理 登录验证实现如下：

  • 前台学生登录传入账户，后台根据账户获取学生密码

  • 返回学生密码，前台登录焦点离开密码框使用 JavaScript 判断

  • @param studentAccount 学生登录账户

  • @param response

  • @throws IOException

*/

@RequestMapping(“/validateLoginStudent”)

public void validateLoginStudent(@RequestParam(“studentAccount”) String studentAccount,

HttpServletResponse response) throws IOException {

logger.info(“学生账户 “+studentAccount+”，尝试登录考试”);

//获取需要登录的学生对象

StudentInfo student = studentInfoService.getStudentByAccountAndPwd(studentAccount);

if (student == null) {

logger.error(“登录学生账户 “+studentAccount+” 不存在”);

response.getWriter().print(“n”);

} else {

logger.error(“登录学生账户 “+studentAccount+” 存在”);

response.getWriter().print(student.getStudentPwd());

/**

  • 学生登录考试

  • @param student 登录学生

  • @param request

  • @return

*/

@RequestMapping(value=”/studentLogin”, method=RequestMethod.POST)

public ModelAndView studentLogin(StudentInfo student, HttpServletRequest request) {

ModelAndView model = new ModelAndView();

StudentInfo loginStudent = studentInfoService.getStudentByAccountAndPwd(student.getStudentAccount());

logger.info(“学生 “+loginStudent+” 有效登录”);

if(loginStudent == null || !student.getStudentPwd().equals(loginStudent.getStudentPwd())){

model.setViewName(“reception/suc”);

model.addObject(“success”, “密码错误”);

return model;

request.getSession().setAttribute(“loginStudent”, loginStudent);

model.setViewName(“reception/suc”);

model.addObject(“success”, “登录成功”);

return model;

/**

  • 退出登录

  • @param session

  • @return

*/

@RequestMapping(“/exit”)

public String studentClearLogin(HttpSession session) {

StudentInfo studnet = (StudentInfo) session.getAttribute(“loginStudent”);

logger.info(“学生 “+studnet.getStudentName()+”, 编号 “+studnet.getStudentId()+” 退出登录”);

session.removeAttribute(“loginStudent”);

return “redirect:index.jsp”;

/**

  • 学生注册 验证当前账户是否被占用

  • @param studentAccount 注册账户

  • @param response

  • @throws IOException

*/

@RequestMapping(“/validateAccount”)

public void validateRegisterAccount(@RequestParam(“studentAccount”) String studentAccount,

HttpServletResponse response) throws IOException {

logger.info(“验证学生账户 “+studentAccount+”，是否已被注册”);

StudentInfo student = studentInfoService.getStudentByAccountAndPwd(studentAccount);

if (student == null) {

logger.error(“注册学生账户 “+studentAccount+” 可以注册”);

response.getWriter().print(“t”);

} else {

logger.error(“注册学生账户 “+studentAccount+” 已被注册”);

response.getWriter().print(“f”);

/**

  • 学生注册

  • @param studentName

  • @param studentAccount

  • @param studentPwd

  • @param classId

  • @param response

  • @throws IOException

*/

@RequestMapping(value=”/studentReg”, method=RequestMethod.POST)

public void studentRegister(

@RequestParam(“name”) String studentName,

@RequestParam(“account”) String studentAccount,

@RequestParam(“pwd”) String studentPwd,

@RequestParam(“classId”) Integer classId,

HttpServletResponse response) throws IOException {

ModelAndView model = new ModelAndView();

student.setStudentName(studentName);

student.setStudentAccount(studentAccount);

student.setStudentPwd(studentPwd);

classInfo.setClassId(classId);

student.setClassInfo(classInfo);

logger.info(“学生注册 “+student);

int row = studentInfoService.isAddStudent(student);

response.getWriter().print(“t”);

/**

  • 预注册

  • @return

*/

@RequestMapping(“/preStudentReg”)

public ModelAndView preStudentReg() {

ModelAndView model = new ModelAndView();

model.setViewName(“reception/register”);

model.addObject(“classs”, classInfoService.getClasses(null));

return model;

/**

  • 学生进入考试

  • @param classId 班级编号

  • @param examPaperId 试卷编号

  • @param studentId 考生编号

  • @param examTime 考试时间

  • @param beginTime 考试开始时间

  • @param gradeId 系部编号

  • @param session

  • @return

*/

@RequestMapping(“/begin”)

public ModelAndView beginExam(

@RequestParam(“classId”) Integer classId,

@RequestParam(“examPaperId”) Integer examPaperId,

@RequestParam(value=”studentId”, required=false) Integer studentId,

@RequestParam(“examTime”) Integer examTime,

@RequestParam(“beginTime”) String beginTime,

@RequestParam(“gradeId”) Integer gradeId,

HttpSession session) {

ModelAndView model = new ModelAndView();

/*

  • 查询该考试当前进入的试卷是否已经在历史记录中存在

  • 如果存在，则不能再次进入考试； 反之进入考试

*/

Map<String, Object> map = new HashMap<String, Object>();

map.put(“studentId”, studentId);

map.put(“examPaperId”, examPaperId);

int count = examHistoryPaperService.getHistoryInfoWithIds(map);

if(session.getAttribute(“loginStudent”) == null) {

model.addObject(“error”, “请先登录后再操作”);

model.setViewName(“error”);

return model;

} else if (count >= 1) {

model.addObject(“error”, “不能重复考试”);

model.setViewName(“error”);

return model;

} else {

logger.info(“学生 “+studentId+” 进入考试 班级 “+classId+” 试卷 “+examPaperId);

model.setViewName(“/reception/exam”);

ExamPaperInfo examPaper = new ExamPaperInfo();

examPaper.setExamPaperId(examPaperId);

esm.setExamPaper(examPaper);

//获取试卷 试题集合

List esms = examSubjectMiddleInfoService.getExamPaperWithSubject(esm);

logger.info(“考试试题总量 “+esms.size());

//获取当前考生在当前试卷中已选答案记录

Map<String, Object> choosedMap = new HashMap<String, Object>();

choosedMap.put(“studentId”, studentId);

choosedMap.put(“examPaperId”, examPaperId);

List chooses = examChooseInfoService.getChooseInfoWithSumScore(choosedMap);

if (chooses == null || chooses.size() == 0) {

model.addObject(“chooses”, null);

} else {

model.addObject(“chooses”, chooses);

model.addObject(“esms”, esms);

model.addObject(“sumSubject”, esms.size());

model.addObject(“examPaperId”, examPaperId);

model.addObject(“examTime”, examTime);

model.addObject(“beginTime”, beginTime);

model.addObject(“classId”, classId);

model.addObject(“gradeId”, gradeId);

return model;

/**

  • 获取学生历史考试记录

  • @param studentId 学生编号

  • @return

*/

@RequestMapping(“/history/{studentId}”)

public ModelAndView getExamHistoryInfo(@PathVariable(“studentId”) Integer studentId) {

ModelAndView model = new ModelAndView();

if (studentId == null) {

logger.error(“学生编号 为空”);

model.setViewName(“error”);

return model;

logger.info(“学生 “+studentId+” 获取考试历史记录”);

//获取历史考试信息记录集合

List ehps = examHistoryPaperService.getExamHistoryToStudent(studentId);

model.addObject(“ehps”, ehps);

model.setViewName(“/reception/examHistory”);

return model;

/**

  • 考生提交考试

  • @param studentId

  • @param examPaperId

  • @param classId

  • @param gradeId

  • @return

*/

@RequestMapping(value=”/submit”, method={RequestMethod.POST, RequestMethod.GET})

public String examSubmit(

@RequestParam(“studentId”) Integer studentId,

@RequestParam(“examPaperId”) Integer examPaperId,

@RequestParam(“classId”) Integer classId,

@RequestParam(“gradeId”) Integer gradeId) {

logger.info(“学生 “+studentId+” 提交了试卷 “+examPaperId);

//获取当前学生当前试卷所选择的全部答案

Map<String, Object> map = new HashMap<String, Object>();

map.put(“studentId”, studentId);

map.put(“examPaperId”, examPaperId);

List chooses = examChooseInfoService.getChooseInfoWithSumScore(map);

logger.info(“学生 “+studentId+” 共选择了 “+chooses.size()+” 道题”);

//总分记录

int sumScore = 0;

for (ExamChooseInfo choose : chooses) {

SubjectInfo subject = choose.getSubject();

String chooseResult = choose.getChooseResult();

String rightResult = subject.getRightResult();

if (chooseResult.equals(rightResult)) { //答案正确

sumScore += subject.getSubjectScore();

logger.info(“学生 “+studentId+” 第 “+subject.getSubjectId()+” 选择正确答案 “+chooseResult+” 当前总分 “+sumScore);

} else {

logger.info(“学生 “+studentId+” 第 “+subject.getSubjectId()+” 答案选择错误 “+chooseResult+” 正确答案为 “+rightResult+” 当前总分 “+sumScore);

/*

  • 首先判断当前记录是否已经添加过

  • 防止当前学生点击提交后，系统倒计时再次进行提交

*/

int count = examHistoryPaperService.getHistoryInfoWithIds(map);

if (count == 0) {

//添加到历史记录

map.put(“examScore”, sumScore);

int row = examHistoryPaperService.isAddExamHistory(map);

logger.info(“学生 “+studentId+” 提交的试卷 “+examPaperId+” 已成功处理，并添加到历史记录中”);

return “redirect:willexams?gradeId=”+gradeId+”&classId=”+classId+”&studentId=”+studentId;

/**

  • 学生回顾试卷 – 后台教师查看也调用此方法

  • @param studentId

  • @param examPaperId

  • @param score

  • @param examPaperName

  • @param studentName 后台教师查看需传入学生姓名

  • @return

  • @throws UnsupportedEncodingException

*/

@RequestMapping(“/review”)

public ModelAndView reViewExam(

@RequestParam(“studentId”) Integer studentId,

@RequestParam(“examPaperId”) Integer examPaperId,

@RequestParam(“score”) Integer score,

@RequestParam(“examPaperName”) String examPaperName,

@RequestParam(value=”studentName”, required=false) String studentName) throws UnsupportedEncodingException {

ModelAndView model = new ModelAndView();

if (studentId == null) {

model.addObject(“error”, “请先登录后再操作”);

model.setViewName(“error”);

return model;

} else {

//获取当前试卷的试题集合 – 前台判断需要

examPaper.setExamPaperId(examPaperId);

esm.setExamPaper(examPaper);

List esms = examSubjectMiddleInfoService.getExamPaperWithSubject(esm);

Map<String, Object> map = new HashMap<String, Object>();

map.put(“studentId”, studentId);

map.put(“examPaperId”, examPaperId);

//获取当前回顾试卷 试题、选择答案 信息

List reviews = examChooseInfoService.getChooseInfoWithExamSubject(map);

logger.info(“学生 “+studentId+” 回顾试卷 “+examPaperId+” 试题数量 “+reviews.size());

//设置试卷名称、试卷总分

model.addObject(“examPaperName”, examPaperName);

model.addObject(“score”, score);

model.setViewName(“reception/review”);

model.addObject(“views”, reviews);

model.addObject(“esms”, esms);

if (studentName != null) model.addObject(“studentName”, studentName);

model.addObject(“ExamedPaper”, examPaperInfoService.getExamPaper(examPaperId));

return model;

/**

  • 学生查看自己信息

  • @param studentId

  • @return

*/

@RequestMapping(“/self/{studentId}”)

public ModelAndView selfInfo(@PathVariable(“studentId”) Integer studentId) {

StudentInfo stu = studentInfoService.getStudentById(studentId);

ModelAndView model = new ModelAndView();

model.setViewName(“/reception/self”);

model.addObject(“self”, stu);

return model;

/**

  • 学生修改密码

  • @param pwd

  • @param studentId

  • @param response

  • @throws IOException

*/

@RequestMapping(“/reset/{pwd}/{studentId}”)

public void isResetPwd(

@PathVariable(“pwd”) String pwd,

@PathVariable(“studentId”) Integer studentId,

HttpServletResponse response) throws IOException {

logger.info(“学生 “+studentId+” 修改密码”);

student.setStudentId(studentId);

student.setStudentPwd(pwd);

int row = studentInfoService.isResetPwdWithStu(student);

if (row > 0) {

response.getWriter().print(“t”);

} else {

response.getWriter().print(“f”);

科目管理控制层：

@Controller

@SuppressWarnings(“all”)

public class CourseInfoHandler {

@Autowired

private CourseInfoService courseInfoService;

@Autowired

private GradeInfoService gradeInfoService;

private Logger logger = Logger.getLogger(CourseInfoHandler.class);

/**

  • 获取科目信息

  • @param gradeId

  •        系部编号

  • @param division

  •        分科情况

  • @return

*/

@RequestMapping(“/courses”)

public ModelAndView getCourses(@RequestParam(value = “gradeId”, required = false) Integer gradeId,

@RequestParam(value = “division”, required = false) Integer division) {

ModelAndView model = new ModelAndView();

model.setViewName(“/admin/course/courses”);

CourseInfo course = new CourseInfo();

if (gradeId != null)

course.getGrade().setGradeId(gradeId);

if (division != null)

course.setDivision(division);

List courses = courseInfoService.getCourses(course);

model.addObject(“courses”, courses);

return model;

/**

  • 根据科目编号获取学科信息

  • @param courseId

  •        科目编号

  • @return

*/

@RequestMapping(“/course/{courseId}”)

public ModelAndView getCourseById(@PathVariable(“courseId”) Integer courseId) {

ModelAndView model = new ModelAndView();

model.setViewName(“/admin/course/courseedit”);

CourseInfo course = courseInfoService.getCourseById(courseId);

model.addObject(“course”, course);

/** 获取所有系部列表 */

List grades = gradeInfoService.getGrades();

model.addObject(“grades”, grades);

return model;

/**

  • 添加/修改科目信息

  • @param courseId

  •        科目编号

  • @param isUpdate

  •        标识是否为修改操作

  • @param courseName

  •        科目名称

  • @param division

  •        分科情况

  • @param gradeId

  •        系部编号

  • @return

*/

@RequestMapping(value = “/course/course”, method = RequestMethod.POST)

public String isUpdateOrAddCourse(@RequestParam(value = “courseId”, required = false) Integer courseId,

@RequestParam(value = “isupdate”, required = false) Integer isUpdate,

@RequestParam(“courseName”) String courseName, @RequestParam(“division”) Integer division,

@RequestParam(“gradeId”) Integer gradeId) {

CourseInfo course = new CourseInfo();

course.setCourseId(courseId);

course.setCourseName(courseName);

course.setDivision(division);

GradeInfo grade = new GradeInfo();

grade.setGradeId(gradeId);

course.setGrade(grade);

// 修改

if (isUpdate != null) {

int row = courseInfoService.isUpdateCourse(course);

// 添加

else {

int row = courseInfoService.isAddCourse(course);

return “redirect:/courses”;

/**

  • 删除科目

  • @param courseId

  •        待删除科目编号

  • @return

*/

@RequestMapping(value = “/course/{courseId}”, method = RequestMethod.DELETE)

public String isDelTeacher(@PathVariable(“courseId”) Integer courseId) {

int row = courseInfoService.isDelCourse(courseId);

return “redirect:/courses”;

/**

  • 预添加科目信息

  • @return

*/

@RequestMapping(“/preAddCourse”)

public ModelAndView preAddCourse() {

ModelAndView model = new ModelAndView();

model.setViewName(“/admin/course/courseedit”);

/** 获取系部集合 */

List grades = gradeInfoService.getGrades();

model.addObject(“grades”, grades);

return model;

项目链接：
https://javayms.github.io?id=102325042508201ta
https://javayms.pages.dev?id=102325042508201ta