基于javaweb+mysql的springboot前台+后台在线考试系统设计和实现(java+springboot+ssm+mysql+thymeleaf+html+maven)

最新推荐文章于 2024-06-11 16:29:10 发布

m0_71095879

最新推荐文章于 2024-06-11 16:29:10 发布

阅读量121

点赞数

文章标签： java mysql spring boot

本文链接：https://blog.csdn.net/m0_71095879/article/details/132251970

版权

基于javaweb+mysql的springboot前台+后台在线考试系统设计和实现(java+springboot+ssm+mysql+thymeleaf+html+maven)

运行环境

Java≥8、MySQL≥5.7

开发工具

eclipse/idea/myeclipse/sts等均可配置运行

适用

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

功能说明

基于javaweb+mysql的SpringBoot前台+后台在线考试系统设计和实现(java+springboot+ssm+mysql+thymeleaf+html+maven)

一、项目简述

本系统主要实现的功能有：学生以及老师的注册登录，在线考试，错题查询，学生管理，问题管理，错题管理，错题查询，分数查询，试卷管理，人工组卷。自动组卷，教师，班级，统计等等管理功能。

二、项目运行

环境配置： Jdk1.8 + Tomcat8.5 + mysql + Eclispe (IntelliJ IDEA,Eclispe,MyEclispe,Sts 都支持)

项目技术： Springboot+ SpringMVC + MyBatis + ThymeLeaf + JavaScript + JQuery + Ajax + maven等等


@Controller
@RequestMapping("/student")
public class StudentController {
    @Autowired
    private ClasseMapper classeMapper;
    @Autowired
    private StudentService studentService;
//查看所有学生
    @RequestMapping("/getAllStudent")
    public String getAllStudent(Model model){
        List<Student> students = studentService.getAll();
        model.addAttribute("students",students);
        return "student/studentList";
    }

//修改编辑功能,先获取该id得学生信息
    @RequestMapping("/{id}")
    public String updateStudent(@PathVariable("id") Integer id,Model model){
        Student student=studentService.getStudentById(id);
        List<Classe> classes = classeMapper.queryAll();
        model.addAttribute("classes",classes);
        model.addAttribute("student",student);
        return "student/studentEdit";
    }
//更改学生信息
    @RequestMapping("/editStudent")
    public String EditStudent(Student student){
        studentService.EditStudent(student);
        return "redirect:/student/getAllStudent";
    }
//删除学生
    @RequestMapping("/deleteStudent/{id}")

    @RequestMapping("/")
    public String view(Model model){
        //查询所有用户
        int teas=teacherService.queryCountAll();
        int stus=studentService.queryCOuntALlstu();
        int alllogers=teas+stus;
        //统计试题
        int allQues=questionService.queryCountAllQues();
        //统计试卷
        int allPaps=paperService.queryCountALlPaps();
        model.addAttribute("allPaps",allPaps);
        model.addAttribute("allQues",allQues);
        model.addAttribute("alllogers",alllogers);
        return "stage/prexam";
    }
    //后台切换到前台登录
    @RequestMapping("/foreLogin")
    public String foreLogin(){
        return "stage/login";
    }
    //前台切换到后台登录
    @RequestMapping("/backLogin")
    public String backLogin(){
        return "stage/loginx";
    }

    //后台教师登录验证
    @ResponseBody
    @RequestMapping("/backLogin/check")
    public Object backCheck(Teacher teacher, HttpServletRequest request){
        AjaxResult result=new AjaxResult();
        HttpSession session=request.getSession();
        Teacher teac=teacherService.check(teacher);
        if(teac!=null){
            session.setAttribute("logerd",teac);
            result.setSuccess(true);
        }else {
            result.setSuccess(false);
        }
        return result;

    @Autowired
    private TeacherService teacherService;
//查看所有班级
    @RequestMapping("/getAllClasse")
    public String getAllClasse(Model model){
        List<Classe> classes = classeService.getAll();
        model.addAttribute("classes",classes);
        return "classe/classeList";
    }

//班级添加或者修改操作，先去添加页面
    @RequestMapping("/toAddClasse")
    public String toAddClasse(Model model){
        List<Teacher> teachers=teacherService.queryTeacherNotAdvisor();
        model.addAttribute("teachers",teachers);
        return "classe/classeAdd";
    }

//添加具体操作
    @RequestMapping("/addClasse")
    public String addClasse(Classe classe){
        classeService.addClasse(classe);
        return "redirect:/classe/getAllClasse";
    }

//班级去修改页面
    @RequestMapping("/toEditClasse/{id}")
    public String toEditClasse(@PathVariable("id") Integer id,Model model){
        //根据id查询班级
        Classe classe=classeService.getClasseById(id);
        //过去班级的班主任，回显
        int teacherIdd=classe.getTeacherId();
        Teacher teacherold=teacherService.getTeacherById(teacherIdd);
        //查询可分配班主任得教师
        List<Teacher> teachers=teacherService.queryTeacherNotAdvisor();
        teachers.add(teacherold);
        model.addAttribute("teachers",teachers);
        model.addAttribute("classe",classe);
        return "classe/classeEdit";
    }

//修改具体操作
    @RequestMapping("/EditClasse")
    public String EditClasse(Classe classe){
        classeService.editClasse(classe);
        return "redirect:/classe/getAllClasse";
    }

//班级删除
    @RequestMapping("/deleteClasse/{id}")

                double accre=(double)accScore/allScore;
                //四舍五入保留2位
                double acc = (double) Math.round(accre * 100) / 100;

                ClaAcc claAcc=new ClaAcc();
                claAcc.setExamName(exaName);
                claAcc.setClaName(claName.getClasseName());
                claAcc.setToscPer(allScore);
                claAcc.setAcscPer(accScore);
                claAcc.setAcc(acc);
                //每个对象添加到list
                claAccRes.add(claAcc);
            }
        }
        model.addAttribute("claAccRes",claAccRes);
        return "record/claAcc";
    }
}

@Controller
@RequestMapping("/classe")
public class ClasseController {
    @Autowired
    private ClasseService classeService;
    @Autowired
    private TeacherService teacherService;
//查看所有班级
    @RequestMapping("/getAllClasse")

        return "redirect:/paper/toManagerQuestion/"+papid;
    }
}

@Controller
@RequestMapping("/exam")
public class ExamController {
    @Autowired
    private ExamService examService;
    @Autowired
    private PaperService paperService;
    @Autowired
    private RecordService recordService;

    //前台跳转
    @RequestMapping("/toExam")
    public String toExam(Model model){
        List<Exam> Exams = examService.getAll();
        model.addAttribute("Exams",Exams);
        return "exam/examplan";
    }
    
    @RequestMapping("/toError")
    public String toError(Model model){
    	List<Exam> Exams = examService.getAll();
    	model.addAttribute("Exams",Exams);
    	return "exam/error";
    }
    @RequestMapping("/tomError")
    public String tomError(Model model){
    	List<Exam> Exams = examService.getAll();
    	model.addAttribute("Exams",Exams);

    private QuestionService questionService;
    @Autowired
    private TeacherService teacherService;
    @Autowired
    private PaperService paperService;
    //查看所有试题 pagesize控制每页数据条数
    @RequestMapping("/getAllQuestion")
    public String getAllQuestion(Question question,@RequestParam(defaultValue = "1") int pageNum,
                                 @RequestParam(defaultValue = "4") int pageSize,
                                 Model model){
        //查找所有题目课程和所有类型，且去重
        List<Question> questionCourses=questionService.queryAllCourse();
        questionCourses.add(new Question("bug","all"));
        List<Question> questionTypes=questionService.queryAllType();
        questionTypes.add(new Question("k","bug"));
        String questionCourseBef = question.getQuestionCourse();
        String questionCourseresRes="";
        if(questionCourseBef==null){
            //默认查询所有
            questionCourseresRes="all";
        }else {
            questionCourseresRes=questionCourseBef;
        }
        //若是第一次查询则用上次提交的表单中的类型、课程，若是第二次查询则延用上次类型
        String questionTypeBef=question.getQuestionType();
        String questionTypesRes="";
        if(questionTypeBef==null){
            //默认查询所有
            questionTypesRes="k";
        }else {
            questionTypesRes=questionTypeBef;
        }
        List<Question> questionids=paperService.queryALlQuestionId();
        List<Integer> quesIds=new ArrayList<>();
        for(Question qid:questionids){
            quesIds.add(qid.getQuestionId());
        }
        model.addAttribute("quesIds",quesIds);

        PageHelper.startPage(pageNum,pageSize);//这行是重点，表示从pageNum页开始，每页pageSize条数据
        List<Question> questions = questionService.getAll(question);
        PageInfo<Question> pageInfo = new PageInfo<Question>(questions);
        model.addAttribute("questionCourseresRes",questionCourseresRes);
        model.addAttribute("questionTypesRes",questionTypesRes);
        model.addAttribute("questionTypes",questionTypes);
        model.addAttribute("questionCourses",questionCourses);
        model.addAttribute("pageInfo",pageInfo);
        return "question/questionList";
    }
//试题添加或者修改操作，先去添加页面

    public String getAllRecord(Model model){
        List<Record> records=recordService.queryAll();
        model.addAttribute("records",records);
        return "record/RecordList";
    }
    //删除记录
    @RequestMapping("/deleteRecore/{id}")
    public String deleteRecore(@PathVariable ("id") Integer id){
        recordService.deleteById(id);
        return "redirect:/record/getAllRecord";
    }
    //根据记录id获取试卷详情
    @RequestMapping("/toShowExamHist/{id}")
    public String toShowExamHist(@PathVariable ("id")Integer id,Model model){
        //通过记录id查找试卷和答题记录
        Integer papid=recordService.queryByRecordId(id);
        String answers=recordService.queryAnsByRecordId(id);
        //原始试卷
        List<QuestionPaper> questionPapers = paperService.paperQueryALlQuestionByIdOrderByType(papid);
        //提交过的答案
        List<String> ans = Arrays.asList(answers.split(","));
        model.addAttribute("questionPapers",questionPapers);
        model.addAttribute("ans",ans);
        return "record/showExamHist";
    }

    //显示所有班级记录
    @RequestMapping("/showClaAcc")
    public String showClaAcc(Model model){
        //查询所有测试名称
        List<Record> records=recordService.queryAllExam();
        List<ClaAcc> claAccRes=new ArrayList<>();
        //按照测试名称查询所有班级
        for(Record rec:records){
            //通过记录对应考试paperid查找总分***
            int paperid=rec.getPaperId();
            int toscore=recordService.queryToscore(paperid);
            //记录考试名
            String exaName=rec.getRecordName();
            List<Classe> clas=recordService.queryAllClass(exaName);
            //初始化所有人和及格人数
            int allScore=0;
            int accScore=0;
            for(Classe cla:clas){

        PageInfo<Question> pageInfo = new PageInfo<Question>(questions);
        model.addAttribute("questionCourseresRes",questionCourseresRes);
        model.addAttribute("questionTypesRes",questionTypesRes);
        model.addAttribute("questionTypes",questionTypes);
        model.addAttribute("questionCourses",questionCourses);
        model.addAttribute("pageInfo",pageInfo);
        return "question/questionList";
    }
//试题添加或者修改操作，先去添加页面
    @RequestMapping("/toAddQuestion")
    public String toAddQuestion(Model model){
        List<Question> questionCourses=questionService.queryAllCourse();
        List<Question> questionTypes=questionService.queryAllType();
        model.addAttribute("questionTypes",questionTypes);
        model.addAttribute("questionCourses",questionCourses);
        return "question/questionAdd";
    }

    //添加具体操作
    @RequestMapping("/addQuestion")
    public String addQuestion(Question question){
        questionService.addQuestion(question);
        return "redirect:/question/getAllQuestion";
    }

//试题去修改页面
    @RequestMapping("/toEditQuestion/{id}")
    public String toEditQuestion(@PathVariable("id") Integer id,Model model){
        List<Question> questionCourses=questionService.queryAllCourse();
        List<Question> questionTypes=questionService.queryAllType();
        Question question=questionService.getQuestionById(id);
        model.addAttribute("questionTypes",questionTypes);
        model.addAttribute("questionCourses",questionCourses);
        model.addAttribute("question",question);
        return "question/questionEdit";
    }

    //修改具体操作
    @RequestMapping("/EditQuestion")
    public String EditQuestion(Question question){
        questionService.editQuestion(question);
        return "redirect:/question/getAllQuestion";

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        Date begin = sdf.parse(t1);
        Date end = sdf.parse(t2);
        exam.setExamBegin(begin);
        exam.setExamEnd(end);
        examService.AddExam(exam);
        return "redirect:/exam/getAllExam";
    }
    @RequestMapping("/deleteExam/{id}")
    public String toEditExam(@PathVariable ("id") Integer id,Model model){
        examService.deleteById(id);
        return "redirect:/exam/getAllExam";
    }
}

@Controller
@RequestMapping("/question")
public class QuestionController {
    @Autowired

        model.addAttribute("questionTypesRes",questionTypesRes);
        model.addAttribute("questionTypes",questionTypes);
        model.addAttribute("questionCourses",questionCourses);
        model.addAttribute("pageInfo",pageInfo);
        model.addAttribute("paperId",paperId);
        return "paper/AddQuestion";
    }
    //为试卷添加试题
    @RequestMapping("/AddQuestion")
    public String AddQuestion(Integer paperId,Integer quesId,Integer pageNum,String questionCourse,String questionType){
        QuestionPaper questionPaper=new QuestionPaper(quesId,paperId);
        paperService.AddQuestionToPaperById(questionPaper);
        return "redirect:/paper/toAddQuestion/"+paperId+"?pageNum="+pageNum+"&questionCourse="+questionCourse+"&questionType="+questionType;
    }
    //从试卷中移除试题
    @RequestMapping("/detachQuestion")
    public String detachQuestion(Integer qpId,Integer paperId){
        paperService.detachQuestionById(qpId);
        return "redirect:/paper/toManagerQuestion/"+paperId;
    }

    //去往随机组题页面
    @RequestMapping("/toRandomQuestion/{id}")
    public String toRandomQuestion(@PathVariable ("id") Integer papid,Question question,Model model){
        List<Question> questionCourses=questionService.queryAllCourse();
        questionCourses.add(new Question("bug","all"));
        //查找所有题目课程和所有类型，且去重
        //用于条件查询题库中尚未分配的题有多少道
        int TotalQuestionNums=questionService.queryAllQuestionNums();
        List<Map> maps = questionService.queryNumOfQuestionType();
        List<String> course=new ArrayList<>();
        List<Integer> count=new ArrayList<>();
        for (Map map:maps){
            for (Object key : map.keySet()) {
                if(map.get(key) instanceof String){
                    course.add(map.get(key).toString());
                }else{
                    count.add(Integer.parseInt(map.get(key).toString()));
                }
            }
        }
        Paper paperName=paperService.queryPaperNameById(papid);
        model.addAttribute("paperName",paperName.getPaperName());
        model.addAttribute("count",count);
        model.addAttribute("course",course);
        model.addAttribute("TotalQuestionNums",TotalQuestionNums);
        model.addAttribute("paperId",papid);
        model.addAttribute("questionCourses",questionCourses);

        return "question/questionList";
    }
//试题添加或者修改操作，先去添加页面
    @RequestMapping("/toAddQuestion")
    public String toAddQuestion(Model model){
        List<Question> questionCourses=questionService.queryAllCourse();
        List<Question> questionTypes=questionService.queryAllType();
        model.addAttribute("questionTypes",questionTypes);
        model.addAttribute("questionCourses",questionCourses);
        return "question/questionAdd";
    }

    //添加具体操作
    @RequestMapping("/addQuestion")
    public String addQuestion(Question question){
        questionService.addQuestion(question);
        return "redirect:/question/getAllQuestion";
    }

//试题去修改页面
    @RequestMapping("/toEditQuestion/{id}")
    public String toEditQuestion(@PathVariable("id") Integer id,Model model){
        List<Question> questionCourses=questionService.queryAllCourse();
        List<Question> questionTypes=questionService.queryAllType();
        Question question=questionService.getQuestionById(id);
        model.addAttribute("questionTypes",questionTypes);
        model.addAttribute("questionCourses",questionCourses);
        model.addAttribute("question",question);
        return "question/questionEdit";
    }

    //修改具体操作
    @RequestMapping("/EditQuestion")
    public String EditQuestion(Question question){
        questionService.editQuestion(question);
        return "redirect:/question/getAllQuestion";
    }

    //试题删除
    @RequestMapping("/deleteQuestion/{id}")
    public String deleteQuestionById(@PathVariable("id") Integer id){
        questionService.deleteQuestionById(id);
        return "redirect:/question/getAllQuestion";
    }

}

    }
}

@Controller
@RequestMapping("/record")
public class RecordController {
    @Autowired
    RecordService recordService;
    @Autowired
    PaperService paperService;
    @Autowired
    ClasseService classeService;

    //获取所有记录
    @RequestMapping("/getAllRecord")
    public String getAllRecord(Model model){
        List<Record> records=recordService.queryAll();
        model.addAttribute("records",records);
        return "record/RecordList";
    }
    //删除记录
    @RequestMapping("/deleteRecore/{id}")
    public String deleteRecore(@PathVariable ("id") Integer id){
        recordService.deleteById(id);
        return "redirect:/record/getAllRecord";
    }
    //根据记录id获取试卷详情
    @RequestMapping("/toShowExamHist/{id}")

    	model.addAttribute("Exams",Exams);
    	return "exam/error";
    }
    @RequestMapping("/tomError")
    public String tomError(Model model){
    	List<Exam> Exams = examService.getAll();
    	model.addAttribute("Exams",Exams);
    	return "exam/merror";
    }

    @RequestMapping("/toHist/{id}")
    public String toHist(@PathVariable ("id") Integer id,Model model){
        List<Record> records=recordService.queryAllExamById(id);
        model.addAttribute("records",records);
        return "exam/histplan";
    }

    //从其他页面跳转到home
    @RequestMapping("/toHome")
    public String tohome(){
        return "redirect:/indexprexam";
    }

    //来到对应考试页面
    @RequestMapping("/toDoExam/{id}")
    public String toDoExam(@PathVariable ("id") Integer id,Model model,String examId,HttpServletRequest request){
       
    	 HttpSession session=request.getSession();
    	 Student stu = (Student) session.getAttribute("loger");
//    	 if() {
//    		 	Record record=new Record();
//    	        record.setStudentId(stu.getStudentId());
//    	        record.setPaperId(id);
    	 List<Record> ss=  recordService.queryAllExamById(stu.getStudentId());
    	 			for (int i = 0; i < ss.size(); i++) {
    	 				if(ss.get(i).getPaperId() ==id ) {
    	 					 return "redirect:/exam/tomError";
    	 				}
						
					}
//    	 }
    	List<QuestionPaper> questionPapers = paperService.paperQueryALlQuestionByIdOrderByType(id);
        int exId=Integer.parseInt(examId);
        Exam examById = examService.getExamById(exId);
        Paper paperName = paperService.queryPaperNameById(examById.getPaperId());

            }
            ans.add(parameter);
        }
        //核对答案得到成绩
        int k=0;    //哨兵
        Double y=0.0;    //正确数
        int score=0;    //得分
        int a=0;        //记录单选题个数
        int b=0;        //记录多选题个数
        int c=0;        //记录判断题个数
        int totalScore=0;
        for (QuestionPaper qb:questionPapers){
        	  if(ans==null) {
              	
              	break;
              }
            //若为单选题则正确+单选题分数
            if(qb.getQuestion().getQuestionType().equals("x")){
                if(ans.get(k).equals(RightAns.get(k))){
                    score+=qb.getPaper().getScoreSin();
                    y++;
                }
                a++;
                k++;
            }else if(qb.getQuestion().getQuestionType().equals("y")){
                if(ans.get(k).equals(RightAns.get(k))){
                    score+=qb.getPaper().getScoreChe();
                    y++;
                }
                b++;
                k++;
            }else {
                if(ans.get(k).equals(RightAns.get(k))){
                    score+=qb.getPaper().getScoreJug();
                    y++;
                }
                c++;
                k++;
            }
        }
        int scoreSin1 = questionPapers.get(0).getPaper().getScoreSin();
        int scoreChe1 = questionPapers.get(0).getPaper().getScoreChe();
        int scoreJug1 = questionPapers.get(0).getPaper().getScoreJug();
        int bool=recordService.queryBooleanToscore(paperId);
        if (bool==0){
        totalScore=scoreSin1*a+scoreChe1*b+scoreJug1*c; //得到每张试卷总分
        Toscore toscore=new Toscore();
        toscore.setPaperId(paperId);
        toscore.setToscore(totalScore);
        recordService.AddToScore(toscore);
        }

//    		 	Record record=new Record();
//    	        record.setStudentId(stu.getStudentId());
//    	        record.setPaperId(id);
    	 List<Record> ss=  recordService.queryAllExamById(stu.getStudentId());
    	 			for (int i = 0; i < ss.size(); i++) {
    	 				if(ss.get(i).getPaperId() ==id ) {
    	 					 return "redirect:/exam/tomError";
    	 				}
						
					}
//    	 }
    	List<QuestionPaper> questionPapers = paperService.paperQueryALlQuestionByIdOrderByType(id);
        int exId=Integer.parseInt(examId);
        Exam examById = examService.getExamById(exId);
        Paper paperName = paperService.queryPaperNameById(examById.getPaperId());
        model.addAttribute("paperName",paperName);
        model.addAttribute("examById",examById);
        model.addAttribute("questionPapers",questionPapers);
        return "exam/doExam";
    }

    //提交试卷
    @RequestMapping("/submitExam")
    public String submitExam(Integer paperId, Integer studentId, HttpServletRequest request){
        List<QuestionPaper> questionPapers = paperService.paperQueryALlQuestionByIdOrderByType(paperId);
        List<String> ans=new ArrayList<>();
        List<String> RightAns=new ArrayList<>();
        for (QuestionPaper qb:questionPapers){
            RightAns.add(qb.getQuestion().getQuestionOpright());
            String parameter="";
            String []parameters;
            if(qb.getQuestion().getQuestionType().equals("y")){
                parameters= request.getParameterValues("optionsSelect" + qb.getQuestionId());
                if(parameters!=null) {
                	
                	for(String s:parameters){
                		parameter+=s;
                	}
                }
            }else {
                parameter = request.getParameter("optionsSelect" + qb.getQuestionId());
                if(parameter==null) {
                	
                	 return "redirect:/exam/toError";
                }
            }
            ans.add(parameter);
        }
        //核对答案得到成绩
        int k=0;    //哨兵
        Double y=0.0;    //正确数
        int score=0;    //得分
        int a=0;        //记录单选题个数

        }
        int nums=questionService.AddAllQues(questionPapers);
        return "redirect:/paper/toManagerQuestion/"+papid;
    }

    @RequestMapping("/deleteAllQues/{id}")
    public String deleteAllQues(@PathVariable ("id") Integer papid,Integer []ques){
        int nums=questionService.queryIdByPapQue(ques);
        return "redirect:/paper/toManagerQuestion/"+papid;
    }
}

@Controller
@RequestMapping("/exam")
public class ExamController {
    @Autowired
    private ExamService examService;
    @Autowired
    private PaperService paperService;
    @Autowired
    private RecordService recordService;

    //前台跳转
    @RequestMapping("/toExam")
    public String toExam(Model model){
        List<Exam> Exams = examService.getAll();
        model.addAttribute("Exams",Exams);
        return "exam/examplan";
    }
    
    @RequestMapping("/toError")
    public String toError(Model model){

    //前台登录到展示页面
    @RequestMapping("/indexprexam")
    public String indexprexam(){
        return "stage/prexamed";
    }

    //退出系统
    @RequestMapping(value = {"*/logout","/logout","teacher/logout"})
    public String logout(HttpSession session) {
        //session里可能不止存放一个数据，移除麻烦，所以让其失效跟直接
        session.invalidate();
        return "redirect:/";
    }

    //学生注册
    //去添加页面
    @RequestMapping("/prexam/toAddStudent")
    public String toAddStudent(Model model){
        List<Classe> allClasees = classeService.getAll();
        model.addAttribute("allClasees",allClasees);
        return "stage/studentAdd";
    }
    //添加具体操作
    @RequestMapping("/prexam/AddStudent")
    public String AddStudent(Student student){
        studentService.AddStudent(student);
        return "redirect:/foreLogin";
    }
    @RequestMapping("/zhao")
    public String zhao(){
        return "stage/zhao";
    }
}

    public String toHist(@PathVariable ("id") Integer id,Model model){
        List<Record> records=recordService.queryAllExamById(id);
        model.addAttribute("records",records);
        return "exam/histplan";
    }

    //从其他页面跳转到home
    @RequestMapping("/toHome")
    public String tohome(){
        return "redirect:/indexprexam";
    }

    //来到对应考试页面
    @RequestMapping("/toDoExam/{id}")
    public String toDoExam(@PathVariable ("id") Integer id,Model model,String examId,HttpServletRequest request){
       
    	 HttpSession session=request.getSession();
    	 Student stu = (Student) session.getAttribute("loger");
//    	 if() {
//    		 	Record record=new Record();
//    	        record.setStudentId(stu.getStudentId());
//    	        record.setPaperId(id);
    	 List<Record> ss=  recordService.queryAllExamById(stu.getStudentId());
    	 			for (int i = 0; i < ss.size(); i++) {
    	 				if(ss.get(i).getPaperId() ==id ) {
    	 					 return "redirect:/exam/tomError";
    	 				}
						
					}
//    	 }
    	List<QuestionPaper> questionPapers = paperService.paperQueryALlQuestionByIdOrderByType(id);
        int exId=Integer.parseInt(examId);
        Exam examById = examService.getExamById(exId);
        Paper paperName = paperService.queryPaperNameById(examById.getPaperId());
        model.addAttribute("paperName",paperName);
        model.addAttribute("examById",examById);
        model.addAttribute("questionPapers",questionPapers);
        return "exam/doExam";
    }

    //提交试卷

请添加图片描述

m0_71095879

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
基于javaweb+mysql的springboot前台+后台在线考试系统设计和实现(java+springboot+ssm+mysql+thymeleaf+html+maven)

本系统主要实现的功能有：学生以及老师的注册登录，在线考试，错题查询，学生管理，问题管理，错题管理，错题查询，分数查询，试卷管理，人工组卷。基于javaweb+mysql的springboot前台+后台在线考试系统设计和实现(java+springboot+ssm+mysql+thymeleaf+html+maven)基于javaweb+mysql的SpringBoot前台+后台在线考试系统设计和实现(java+springboot+ssm+mysql+thymeleaf+html+maven)
复制链接

扫一扫

基于javaweb+mysql的springboot前台+后台在线考试系统设计和实现(java+springboot+ssm+mysql+thymeleaf+html+maven)

“相关推荐”对你有帮助么？