基于javaweb+mysql的springboot学生在线考试管理系统(java+springboot+thymleaf+bootstrap+html+mysql)

基于javaweb+mysql的springboot学生在线考试管理系统(java+springboot+thymleaf+bootstrap+html+mysql)

运行环境

Java≥8、MySQL≥5.7

开发工具

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

适用

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

功能说明

基于javaweb+mysql的SpringBoot学生在线考试管理系统(java+springboot+thymleaf+bootstrap+html+mysql)

项目介绍

学生在线考试管理系统,分为管理员与老师、学生三种角色；

教师/管理员主要功能：

1. 学生管理：查看所有学生的基本信息，管理员则还可以对学生的基本信息（除了账号和密码外）进行修改和对学生的删除操作。

2. 教师管理：查看所有教师的基本信息（除密码外），并修改自己的基本信息，而管理员除了以上功能还可以对所有教师的所有信息进行修改删除操作，也能添加教师。

3. 班级管理：要能对班级的信息进行管理。

4. 试题管理：首先要能对试题进行增删改查，并且应该对试题进行不同科目的分类以方便试卷的生成。

5. 试卷管理：试卷的主体是试题，然后用户能对试卷进行增删改查操作。

6. 考试管理：可以选择相应的试卷设置时间进行考试。考试一旦生成后无法修改。

7. 记录管理：查看试卷的考试情况；以班级为单位根据班级考试情况生成每个考试的不同班级的及格率以方便排名。

学生主要功能：

1. 学生注册：学生可以通过注册一个账号，然后可以用于登陆系统。

2. 参与考试：学生要可以参与考试

3. 查询历史考试情况：学生在考完试后系统便会记录它的考试得分，进行准确率的分析，并提供试卷详情查看，且这此的考试信息会存入数据库中以便于下次查看。

环境需要

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

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

3.tomcat环境：Tomcat 7.x,8.x,9.x版本均可

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

5.是否Maven项目: 是；查看源码目录中是否包含pom.xml；若包含，则为maven项目，否则为非maven项目

6.数据库：MySql 5.7版本；

技术栈

1. 后端：SpringBoot+Mybatis

2. 前端：Thymleaf+BootStrap+Html

使用说明

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

2.使用IDEA/Eclipse/MyEclipse导入项目，Eclipse/MyEclipse导入时，若为maven项目请选择maven;

若为maven项目，导入成功后请执行maven clean;maven install命令，配置tomcat，然后运行；

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

4. 访问地址：http://localhost:8080

    @Autowired
    private ClasseService classeService;
    //查看所有教师
    @RequestMapping("/getAllTeacher")
    public String getAllTeacher(Model model){
        List<Teacher> teachers = teacherService.getAll();
        //查找classe表中已存在的教师，将用于表单教师是否可以删除
        List<Classe> classes=classeService.queryAllTeacherId();
        List<Integer> teaId=new ArrayList<>();
        for(Classe cla:classes){
            teaId.add(cla.getTeacherId());
        }
        model.addAttribute("teaId",teaId);
        model.addAttribute("teachers",teachers);
        return "teacher/teacherList";
    }
    //教师添加或者修改操作，先去添加页面
    @RequestMapping("/toAddTeacher")
    public String toAddTeacher(){
        return "teacher/teacherAdd";
    }

    //添加或者修改具体操作
    @RequestMapping("/addTeacher")
    public String addTeacher(Teacher teacher){
        int teacherId = teacher.getTeacherId();
        if(teacherId==0){
            /*若id为0即是刚添加未分配，要进行增加操作*/
            teacherService.addTeacher(teacher);
        }else {
            /*若id已存在，是要进行修改操作*/
            teacherService.editTeacher(teacher);
        }
        return "redirect:/teacher/getAllTeacher";
    }

    //教师去修改页面
    @RequestMapping("/{id}")
    public String toEditTeacher(@PathVariable("id") Integer id,Model model){
        Teacher teacher=teacherService.getTeacherById(id);
        model.addAttribute("teacher",teacher);
        return "teacher/teacherAdd";

        return "stage/studentAdd";
    }
    //添加具体操作
    @RequestMapping("/prexam/AddStudent")
    public String AddStudent(Student student){
        studentService.AddStudent(student);
        return "redirect:/foreLogin";
    }
    @RequestMapping("/about")
    public String help(){
        return "stage/about";
    }
}

@Controller
@RequestMapping("/record")
@Slf4j
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){

@Controller
public class LoginController {
    @Autowired
    private StudentService studentService;
    @Autowired
    private TeacherService teacherService;
    @Autowired
    private QuestionService questionService;
    @Autowired
    private PaperService paperService;
    @Autowired
    private ClasseService classeService;
    @Autowired
    private RecordService recordService;
    @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";
    }

        model.addAttribute("paper",paper);
        return "paper/paperEdit";
    }
    //试卷修改
    @RequestMapping("/EditPaper")
    public String toEditPaper(Paper paper){
        paperService.editPaper(paper);
        return "redirect:/paper/getAllPaper";
    }
    
    //试卷删除
    @RequestMapping("/deletePaper/{id}")
    public String deletePaperById(@PathVariable("id") Integer id,Model model){
        paperService.deletePaperById(id);
        return "redirect:/paper/getAllPaper";
    }

    //去往试题管理页面
    @RequestMapping("/toManagerQuestion/{id}")
    public String toManagerQuestion(@PathVariable("id") Integer id,Model model){
        List<QuestionPaper> questionPapers = paperService.paperQueryALlQuestionById(id);
        model.addAttribute("papid",id);
        Paper paperName=paperService.queryPaperNameById(id);
        model.addAttribute("paperName",paperName.getPaperName());
        model.addAttribute("questionPapers",questionPapers);
        return "paper/ManagerQuestion";
    }
    //来到试题显示页面为试卷添加试题
    @RequestMapping("/toAddQuestion/{id}")
    public String getAllQuestion(@PathVariable("id") Integer paperId, 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){

@Controller
public class LoginController {
    @Autowired
    private StudentService studentService;
    @Autowired
    private TeacherService teacherService;
    @Autowired
    private QuestionService questionService;
    @Autowired
    private PaperService paperService;
    @Autowired
    private ClasseService classeService;
    @Autowired
    private RecordService recordService;
    @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);

        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;
    }

    @RequestMapping("/index")
    public String index(Model model){
        //查询所有用户
        int teas=teacherService.queryCountAll();
        int stus=studentService.queryCOuntALlstu();

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

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

    @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";
    }

@Controller
@RequestMapping("/question")
public class QuestionController {
    @Autowired
    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);

@Controller
@RequestMapping("/record")
@Slf4j
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}")
    public String toShowExamHist(@PathVariable ("id")Integer id,Model model){
        //通过记录id查找试卷和答题记录
        Integer papid=recordService.queryByRecordId(id);

        return "redirect:/exam/getAllExam";
    }
}

@Controller
@RequestMapping("/question")
public class QuestionController {
    @Autowired
    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";

            result.setSuccess(true);
        }else {
            result.setSuccess(false);
        }
        return result;
    }

    @RequestMapping("/index")
    public String index(Model model){
        //查询所有用户
        int teas=teacherService.queryCountAll();
        int stus=studentService.queryCOuntALlstu();
        int alllogers=teas+stus;
        //统计试题
        int allQues=questionService.queryCountAllQues();
        //统计试卷
        int allPaps=paperService.queryCountALlPaps();
        List<Record> ScoreHStu=recordService.queryRankScoreRecord();
        List<Record> AccHStu=recordService.queryRankAccRecord();
        model.addAttribute("ScoreHStu",ScoreHStu);
        model.addAttribute("AccHStu",AccHStu);
        model.addAttribute("allPaps",allPaps);
        model.addAttribute("allQues",allQues);
        model.addAttribute("alllogers",alllogers);
        return "index";
    }

    //前台学生登录考试
    @ResponseBody
    @RequestMapping("/foreCheck/check")
    public Object foreCheck(Student student, HttpServletRequest request){
        AjaxResult result=new AjaxResult();
        HttpSession session=request.getSession();
        Student stud=studentService.check(student);
        if(stud!=null){
            session.setAttribute("loger",stud);
            result.setSuccess(true);
        }else {
            result.setSuccess(false);
        }
        return result;
    }
    //前台登录到展示页面
    @RequestMapping("/indexprexam")
    public String indexprexam(){
        return "stage/prexamed";
    }

        model.addAttribute("paper",paper);
        return "paper/paperEdit";
    }
    //试卷修改
    @RequestMapping("/EditPaper")
    public String toEditPaper(Paper paper){
        paperService.editPaper(paper);
        return "redirect:/paper/getAllPaper";
    }
    
    //试卷删除
    @RequestMapping("/deletePaper/{id}")
    public String deletePaperById(@PathVariable("id") Integer id,Model model){
        paperService.deletePaperById(id);
        return "redirect:/paper/getAllPaper";
    }

    //去往试题管理页面
    @RequestMapping("/toManagerQuestion/{id}")
    public String toManagerQuestion(@PathVariable("id") Integer id,Model model){
        List<QuestionPaper> questionPapers = paperService.paperQueryALlQuestionById(id);
        model.addAttribute("papid",id);
        Paper paperName=paperService.queryPaperNameById(id);
        model.addAttribute("paperName",paperName.getPaperName());
        model.addAttribute("questionPapers",questionPapers);
        return "paper/ManagerQuestion";
    }
    //来到试题显示页面为试卷添加试题
    @RequestMapping("/toAddQuestion/{id}")
    public String getAllQuestion(@PathVariable("id") Integer paperId, 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){
            //默认查询所有

}

@Controller
@RequestMapping("/classe")
public class ClasseController {
    @Autowired
    private ClasseService classeService;
    @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")

@Controller
@RequestMapping("/paper")
public class PaperController {
    @Autowired
    private PaperService paperService;
    @Autowired
    private ClasseService classeService;
    @Autowired
    private QuestionService questionService;
    //查看所有试卷
    @RequestMapping("/getAllPaper")
    public String getAllPaper(Model model){
        List<Paper> papers = paperService.getAll();
        //查找classe表中已存在的试卷，将用于表单试卷是否可以删除
        model.addAttribute("papers",papers);
        return "paper/paperList";
    }
    //试卷添加或者修改操作，先去添加页面
    @RequestMapping("/toAddPaper")
    public String toAddPaper(){
        return "paper/paperAdd";
    }

    //添加具体操作
    @RequestMapping("/addPaper")
    public String addPaper(Paper paper){
        paperService.addPaper(paper);
        return "redirect:/paper/getAllPaper";
    }

    //试卷去修改页面
    @RequestMapping("/toEditPaper/{id}")
    public String toEditPaper(@PathVariable("id") Integer id,Model model){
        Paper paper=paperService.getPaperById(id);
        model.addAttribute("paper",paper);
        return "paper/paperEdit";
    }
    //试卷修改
    @RequestMapping("/EditPaper")
    public String toEditPaper(Paper paper){
        paperService.editPaper(paper);

    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}")
    public String deleteClasseById(@PathVariable("id") Integer id){
        classeService.deleteClasseById(id);
        return "redirect:/classe/getAllClasse";
    }

            //默认查询所有
            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";
    }
//试题添加或者修改操作，先去添加页面
    @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("/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}")
    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);
            //初始化所有人和及格人数

        record.setRecordName(paperName);
        record.setStudentId(studentId);
        record.setPaperId(paperId);
        record.setRecordAnswer(answer);
        record.setRecordAcc(recordAcc);
        record.setRecordScore(recordScore);
        recordService.addRecord(record);
        return "redirect:/exam/toExam";
    }
    /**
     * 考试后台
     * */
    //查看所有考试安排后台
    @RequestMapping("/getAllExam")
    public String getAllExam(Model model){
        List<Exam> Exams = examService.getAllS();
        model.addAttribute("Exams",Exams);
        return "exam/backexamlist";
    }

    //去往考试添加页面
    @RequestMapping("/toAddExam")
    public String toAddExam(Model model){
        List<Paper> papers = paperService.getAll();
        model.addAttribute("papers",papers);
        return "exam/AddExam";
    }
    //添加操作
    @RequestMapping("/addExam")
    public String addExam(Exam exam, String examBegins,String examEnds) throws ParseException {
        try{
            String t1 = examBegins.replace("T", " ");
            String t2 = examEnds.replace("T", " ");
            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";
        }catch (Exception e){
            e.printStackTrace();
            log.error("考试时间格式错误");
            return "exam/AddExam";