基于javaweb+mysql的ssm在线考试系统(java+ssm+mysql+jsp)
私信源码获取及调试交流
运行环境
Java≥8、MySQL≥5.7、Tomcat≥8
开发工具
eclipse/idea/myeclipse/sts等均可配置运行
适用
课程设计，大作业，毕业设计，项目练习，学习演示等
功能说明
基于javaweb的SSM在线考试系统(java+ssm+mysql+jsp)
运行环境：jdk1.8、Mysql5.7、Tomcat8.5、IDEA/Eclipse
功能简介：在线考试、历史回顾、个人成绩查询等。
管理员和教师功能有：学院管理、班级管理、课程管理、教师、学生管理、统计分析、试卷试题管理、考试安排管理、历史考试管理等
examPaper.setExamPaperEasy(examPaperEasy);
grade.setGradeId(gradeId);
examPaper.setGrade(grade);
if (isUpdate != null) {
logger.info("修改试卷 " + examPaper + " 的信息");
int row = examPaperInfoService.isUpdateExamPaper(examPaper);
} else {
logger.info("添加试卷 " + examPaper + " 的信息");
int row = examPaperInfoService.isAddExamPaper(examPaper);
}
return "redirect:/examPapers";
}
/**
* 删除试卷
*
* @param examPaperId
* 待删除试卷编号
* @return
*/
@RequestMapping(value = "/examPaper/{examPaperId}", method = RequestMethod.DELETE)
public String isDelTeacher(@PathVariable("examPaperId") Integer examPaperId, Model model) {
logger.info("删除试卷 " + examPaperId);
try {
examPaperInfoService.isDelExamPaper(examPaperId);
}catch (Exception e){
e.printStackTrace();
return "redirect:/error";
}
return "redirect:/examPapers";
}
@RequestMapping("/error")
public ModelAndView error(ModelAndView modelAndView){
modelAndView.addObject("error","该试卷有关联数据,不可删除");
modelAndView.setViewName("/error");
return modelAndView;
}
/**
* 预添加试卷
*
* @return
*/
@RequestMapping("/preAddExamPaper")
public ModelAndView preAddStudent() {
logger.info("预添加试卷信息");
ModelAndView model = new ModelAndView();
model.setViewName("/admin/examPaperedit");
List<GradeInfo> grades = gradeInfoService.getGrades();
model.addObject("grades", grades);
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) {
*/
@RequestMapping("/preAddCourse")
public ModelAndView preAddCourse() {
ModelAndView model = new ModelAndView();
model.setViewName("/admin/course/courseedit");
/** 获取系部集合 */
List<GradeInfo> grades = gradeInfoService.getGrades();
model.addObject("grades", grades);
return model;
}
}
/**
*
* <p>
* Title: GradeInfoHandler
* </p>
* <p>
* Description: 系部
* </p>
*/
@Controller
public class GradeInfoHandler {
@Autowired
@Qualifier("gson")
private Gson gson;
@Autowired
private GradeInfoService gradeInfoService;
private Logger logger = Logger.getLogger(GradeInfoHandler.class);
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<GradeInfo> grades = gradeInfoService.getGrades();
model.addObject("grades", grades);
return model;
}
}
return "admin/grade/gradeedit";
}
/**
* 添加系部
*
* @param grade
* @param request
* @return
*/
@RequestMapping(value = "/grade", method = RequestMethod.POST)
public String isAddGrade(GradeInfo grade, HttpServletRequest request) {
if (grade == null) {
request.setAttribute("error", "请填写正确的系部信息");
return "error";
}
GradeInfo byName = gradeInfoService.findByName(grade.getGradeName());
if(byName!=null){
request.setAttribute("error", "该系部名称已存在！");
return "error";
}
int row = gradeInfoService.isAddGrade(grade);
if (row < 1) {
request.setAttribute("error", "系部添加失败，请稍后再试！");
return "error";
}
return "redirect:grades";
}
/**
* 预修改系部处理
*
* @param gradeId
* 待修改系部编号
* @param map
* @return
*/
@RequestMapping(value = "/grade/update/{gradeId}", method = RequestMethod.GET)
public String preUpdateGrade(@PathVariable("gradeId") Integer gradeId, Map<String, Object> map) {
logger.info("系部修改预处理");
map.put("grade", gradeInfoService.getGradeById(gradeId));
return "/admin/grade/gradeedit";
}
/**
* 修改系部信息
*
* 页容量 默认10
* @return
*/
@RequestMapping("/examPapers")
public ModelAndView getCourses(@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("获取试卷集合 gradeId=" + gradeId + ", startPage=" + startPage + ", pageShow=" + pageShow);
ModelAndView model = new ModelAndView();
model.setViewName("/admin/examPapers");
if (gradeId != null) {
grade.setGradeId(gradeId);
examPaper.setGrade(grade);
}
Map<String, Object> map = new HashMap<String, Object>();
// 计算当前查询起始数据索引
int startIndex = (startPage - 1) * pageShow;
map.put("examPaper", examPaper);
map.put("startIndex", startIndex);
map.put("pageShow", pageShow);
List<ExamPaperInfo> examPapers = examPaperInfoService.getExamPapers(map);
model.addObject("examPapers", examPapers);
// 获取试卷总量
int examPaperTotal = examPaperInfoService.getExamPpaerTotal();
// 计算总页数
int pageTotal = 1;
if (examPaperTotal % pageShow == 0)
pageTotal = examPaperTotal / pageShow;
else
pageTotal = examPaperTotal / pageShow + 1;
model.addObject("pageTotal", pageTotal);
model.addObject("pageNow", startPage);
return model;
}
/**
* 根据编号获取试卷信息
*
* @param examPaperId
* 试卷编号
* @return
*/
@RequestMapping("/examPaper/{examPaperId}")
public ModelAndView getCourseById(@PathVariable("examPaperId") Integer examPaperId) {
logger.info("获取试卷 " + examPaperId);
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)) {
/**
*
* <p>Title: StudentInfoHandler</p>
* <p>Description: </p>
*/
@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 学生编号
subject.setSubjectEasy(subjectEasy);
}
if (courseId != null) {
course.setCourseId(courseId);
subject.setCourse(course);
}
if (gradeId != null) {
grade.setGradeId(gradeId);
subject.setGrade(grade);
}
Map<String, Object> map = new HashMap<String, Object>();
map.put("subject", subject);
map.put("startIndex", null);
map.put("pageShow", null);
List<SubjectInfo> subjects = subjectInfoService.getSubjects(map);
int subjectTotal = subjects.size() - 1;
Map<String, Object> addMap = new HashMap<String, Object>();
ArrayList<Integer> indexs = new ArrayList<Integer>();
ArrayList<Integer> subjectIds = new ArrayList<Integer>();
// 添加试题总分
int score = 0;
for (int i = 0; i < subjectSum; i++) {
// 产生随机索引
int index = random.nextInt(subjectTotal);
if (indexs.contains(index)) { // 随机索引已经存在
i--;
continue;
} else {
indexs.add(index);
int subjectId = subjects.get(index).getSubjectId();
subjectIds.add(subjectId);
score += subjects.get(index).getSubjectScore();
logger.info("索引 " + index + " 试题编号 " + subjectId + " 成立");
}
}
// 添加试题信息
addMap.put("examPaperId", examPaperId);
addMap.put("subjectIds", subjectIds);
// 总分和题目数量信息
Map<String, Object> scoreWithNum = new HashMap<String, Object>();
* @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<ExamHistoryPaper> 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);
logger.info("待考试卷 " + examPlanInfo.getExamPaper().getExamPaperId() + " 暂未过期，无法移除");
continue;
}
}
}
}
/**
* 验证试卷是否过期
*
* @param beginTime
* 考试开始时间
* @param examTime
* 考试时间
* @return
*/
private boolean validateExamPaerBeOverdue(String beginTime, int examTime) {
boolean flag = false;
try {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
Date beginTimeDate = sdf.parse(beginTime);
Long beginTimeTime = beginTimeDate.getTime();
/** 转换考试时间为毫秒单位 */
int examTimeSecond = examTime * 60 * 1000;
Date nowDate = new Date();
Long nowDateTime = nowDate.getTime();
/** 当前时间超过了 考试结束时间，即为过期记录 */
if (nowDateTime > (beginTimeTime + examTimeSecond)) {
flag = true;
}
} catch (ParseException e) {
e.printStackTrace();
}
return flag;
}
/**
* 教师移除考试安排记录
*
* 上一个班主任编号，修改其 班主任状态
* @return
*/
@RequestMapping(value = "edit/class/class", method = RequestMethod.POST)
public String isUpdateClass(ClassInfo classInfo, HttpServletRequest request,
@RequestParam(value = "lastTeacher", required = false) Integer lastTeacherId) {
ClassInfo byClassName = classInfoService.findByClassName(classInfo.getClassName());
if(byClassName!=null){
if(!byClassName.getClassId().equals(classInfo.getClassId())){
request.setAttribute("error", "该班级名称已存在！");
return "../../error";
}
}
// 修改上一教师不为班主任状态
if (lastTeacherId != null) {
String returnMsg = isChangeTeacherWork(0, lastTeacherId);
if (returnMsg != null) {
request.setAttribute("error", "修改教师班主任状态 对应教师编号有误");
return "../error";
}
}
// 修改当前教师为班主任状态
String returnMsg = isChangeTeacherWork(1, classInfo.getTeacher().getTeacherId());
if (returnMsg != null) {
request.setAttribute("error", "修改教师班主任状态 对应教师编号有误");
return "../error";
}
int row = classInfoService.isUpdateClass(classInfo);
if (row < 1) {
logger.error("班级 " + classInfo + " 修改失败");
request.setAttribute("error", "班级修改失败，请稍后再试！");
return "../error";
}
return "redirect:/classes";
}
/**
* 获取指定系部下的班级
}
/**
* 退出登录
* @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");
}
}
/**
* 学生注册
public void delSubject(@RequestParam("subjectId") Integer subjectId, HttpServletResponse response)
throws IOException {
logger.info("删除试题 " + subjectId);
int row = subjectInfoService.isDelSubject(subjectId);
if (row > 0) {
response.getWriter().print("t");
} else {
response.getWriter().print("f");
}
}
/**
* 修改试题 -- 获取待修改试题信息
*
* @param subjectId
* @return
*/
@RequestMapping("/subject/{subjectId}")
public ModelAndView updateSubject(@PathVariable("subjectId") Integer subjectId) {
logger.info("修改试题 " + subjectId + " 的信息(获取试题信息)");
SubjectInfo subject = subjectInfoService.getSubjectWithId(subjectId);
ModelAndView model = new ModelAndView("/admin/subject-test");
model.addObject("subject", subject);
List<GradeInfo> grades = gradeInfoService.getGrades();
model.addObject("grades", grades);
model.addObject("courses", courseInfoService.getCourses(null));
return model;
}
/**
* 修改试题
*
* @param subject
* @param response
* @throws IOException
*/
@RequestMapping(value = "/updateSubject", method = RequestMethod.POST)
public void updateSubject(SubjectInfo subject, HttpServletResponse response) throws IOException {
logger.info("修改试题 " + subject.getSubjectId() + " 的信息(正式)");
if (subject != null) {
subject.setSubjectName(trimChar(subject.getSubjectName()));
subject.setRightResult(trimChar(subject.getRightResult()));
subject.setOptionA(trimChar(subject.getOptionA()));
subject.setOptionB(trimChar(subject.getOptionB()));
subject.setOptionC(trimChar(subject.getOptionC()));
subject.setOptionD(trimChar(subject.getOptionD()));
}
int row = subjectInfoService.isUpdateSubject(subject);
if (row > 0) {
/**
*
* <p>
* Title: ExamSubjectMiddleInfoHandler
* </p>
* <p>
* Description: 试卷试题--关联
* </p>
*/
@Controller
@Scope("prototype")
@SuppressWarnings("all")
public class ExamSubjectMiddleInfoHandler {
@Autowired
private ExamSubjectMiddleInfoService esmService;
@Autowired
private ExamPaperInfoService examPaperInfoService;
@Autowired
private SubjectInfoService subjectInfoService;
@Autowired
private ExamSubjectMiddleInfo esm;
@Autowired
private ExamPaperInfo examPaper;
@Autowired
model.addObject("pageNow", startPage);
return model;
}
/**
* 根据编号获取试卷信息
*
* @param examPaperId
* 试卷编号
* @return
*/
@RequestMapping("/examPaper/{examPaperId}")
public ModelAndView getCourseById(@PathVariable("examPaperId") Integer examPaperId) {
logger.info("获取试卷 " + examPaperId);
ModelAndView model = new ModelAndView();
model.setViewName("/admin/examPaperedit");
ExamPaperInfo paper = examPaperInfoService.getExamPaper(examPaperId);
model.addObject("examPaper", paper);
List<GradeInfo> grades = gradeInfoService.getGrades();
model.addObject("grades", grades);
return model;
}
/**
* 添加/修改试卷信息
*
* @param examPaperId
* 待操作试卷编号
* @param isUpdate
* 标识是否为修改操作
* @param examPaperName
* 试卷名称
* @param subjectNum
* 试卷试题数量
* @param examPaperScore
* 试卷总分
* @param examPaperTime
* 试卷规定考试时间
* @param division
subjectIds.add(Integer.parseInt(idAndScore[0]));
// 累加试题分数
scoreSum += Integer.parseInt(idAndScore[1]);
// 累加试题数量
subjectSum += 1;
}
/** 需要添加试题集合 */
map.put("subjectIds", subjectIds);
} else {
logger.error("试题集合为空，不能进行添加试题操作！");
response.getWriter().print("需要添加的试题为空，操作失败！");
return;
}
logger.info("添加试题集合到试卷 " + examPaperId);
// 总分和题目数量信息
Map<String, Object> scoreWithNum = new HashMap<String, Object>();
scoreWithNum.put("subjectNum", subjectSum);
scoreWithNum.put("score", scoreSum);
scoreWithNum.put("examPaperId", examPaperId);
/** 修改试卷总分 */
examPaperInfoService.isUpdateExamPaperScore(scoreWithNum);
/** 修改试卷试题总量 */
examPaperInfoService.isUpdateExamPaperSubjects(scoreWithNum);
/** 添加试题到试卷中 */
esmService.isAddESM(map);
session.setAttribute("ids",null);
response.getWriter().print("试题已成功添加到试卷中！");
}
/**
* 手动添加试题到试卷时 向 Session中存入试题信息
*
* @param subjectId
* 试题编号
* @param examPaperId
* 试卷编号
* @param score
* 试题分数
* @param handle
* 操作标识, 自动 OR 手动
* @param session
* @param response
* @throws IOException
*/
@RequestMapping("/getChooseSubId")
public void getChooseSubjectId(@RequestParam("subjectId") Integer subjectId,
@RequestParam("examPaperId") Integer examPaperId, @RequestParam("score") Integer score,
@RequestParam(value = "handle", required = false) Integer handle, HttpSession session,
HttpServletResponse response) throws IOException {
List<String> ids = null;
/*
* 添加到 Session 中需先判断该试题是否已经存在该试卷中 如果存在，则不进行添加；反之添加
logger.info("获取要修改的待考记录：" + examPlanWithUpdate);
model.addObject("examPlan", examPlanWithUpdate);
return model;
}
/**
* 修改待考信息
*
* @param examPlan
* 待考记录
* @return
*/
@RequestMapping(value = "preUpdateep/examPlan", method = RequestMethod.PUT)
public String isUpdateExamPlan(ExamPlanInfo examPlan) {
logger.info("修改待考记录：" + examPlan);
examPlanInfoService.isUpdateExamPlan(examPlan);
return "redirect:../examPlans";
}
/**
* 查询学生待考信息
*
* @param classId
* 学生所在班级编号
* @param gradeId
* 学生所在系部百年好
* @param studentId
* 学生编号
* @return
*/
@RequestMapping("/willexams")
public ModelAndView getStudentWillExam(@RequestParam("classId") Integer classId,
@RequestParam("gradeId") Integer gradeId,
@RequestParam(value = "studentId", required = false) Integer studentId) {
logger.info("查询学生 " + studentId + "(NULL-未指定)待考信息 班级：" + classId + ", 系部：" + gradeId);
ModelAndView model = new ModelAndView();
model.setViewName("/reception/examCenter");
Map<String, Object> map = new HashMap<String, Object>();
588
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
