Springboot+vue前后端分离考试系统

Posted 2022-06-02 编程指南针

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Springboot+vue前后端分离考试系统相关的知识，希望对你有一定的参考价值。

作者主页：编程指南针

简介：Java领域优质创作者、CSDN博客专家 Java项目、简历模板、学习资料、面试题库、技术互助

文末获取源码

项目编号：BS-XX-104

指南针考试系统是一个多角色在线培训考试系统，系统集成了用户管理、角色管理、题库管理、试题管理、考试管理、在线考试等功能，考试流程完善。实现一整套完整体系的考试系统，方便用户在此系统中进行练习并不断提升自己，在考试中不断进步。本系统采用前后端分离方式进行开发实现，使用springboot+vue来进行开发.

技术栈

SpringBoot
Mybatis-plus
mysql 5.7
Vue全家桶
ElementUI
Redis
Swagger
阿里云OSS
Log4j

主要功能

1. 权限控制

本系统存在三个不同的角色，教师，管理员，学生三种用户，此系统是基于vue+springboot实现的前后端分离，用户权限校验通过JWT生成token令牌发放到用户，并根据令牌对用户的身份合法性进行校验。

2. 在线考试

学生用户在注册登录之后，可以在本系统进行在线的考试，考试可由教师和管理员进行布置并设置考试权限（公开，密码），考试题型分为单选、多选、判断、简答题，并支持题目附带配图。考试过程中需开启摄像头进行考试，系统会自动抓拍考生实时考试状态。

3. 成绩模块

参加考试后的学生用户，在提交试卷后进入考试结果页面，页面会自动核对学生用户的逻辑题的对错，对于简答题需要老师或者超级管理员进行批阅。对于学生用户参与的考试，学生用户可以查看到考试的详情并可以查看到自己所错的逻辑题。

4. 题库模块

学生用户在题库模块中可以进行题目的功能训练，训练模式分为，顺序练习，随机练习，也可以根据题型练习（单选，多选，判断）。用户答题时会实时判断正确与否，并有错题解析功能。

5. 题库管理

超级管理员和教师可以对本考试系统已有的题库进行管理，实现对题库信息的CRUD操作

6. 试题管理

教师和系统管理员用户有权限对本系统的所有试题进行操作，本系统试题支持复杂类型的题目，考试题目支持多插图，选项答案支持单插图功能。

7. 考试管理

教师和系统管理员用户有权限对系统存在的考试进行操作，本系统考试支持公开考试和密码口令考试，并可以对考试进行禁用也可以在设置考试时间段，对于考试可以进行很便利的进行组卷，系统内置两种组卷模式，题库组卷和自由选题组卷。

8. 考卷批阅

对于本系统中存在的复杂考试的题目，可以又对应的老师进行批阅，此系统的逻辑题无需老师用户进行批阅，老师的工作仅仅是批阅简答题这种无准确答案类型的题目，极大地减轻了老师用户的工作量

9. 考试统计

本系统针对每一次考试进行数据统计和报表，让使用本系统的老师用户能够直观的了解到每一次考试人员的进步。

10. 用户管理

超级管理员可以对注册本系统用户的进行授权，并拥有操作一切用户的权限。

下面展示一下系统的主要功能：

登陆：

后台管理首页

题库管理

试题管理

考试管理

阅卷管理

考试统计

公告管理

用户管理

教师登陆

学生登陆

在线考试：考试时要调出摄相头进行监控

查看个人成绩和错题：并为通过考试的生成证书

日常题库训练

部门核心代码：

package com.wzz.controller;

import com.wzz.dto.AddUserDto;
import com.wzz.entity.Notice;
import com.wzz.entity.UserRole;
import com.wzz.service.NoticeService;
import com.wzz.service.UserRoleService;
import com.wzz.service.UserService;
import com.wzz.vo.CommonResult;
import com.wzz.vo.PageResponse;
import com.wzz.vo.UserInfoVo;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.util.List;

/**
 * @author by znz
 * @implNote 2021/10/20 19:07
 */
@Validated
@RestController
@RequiredArgsConstructor
@Api(tags = "超级管理员权限相关的接口")
@RequestMapping(value = "/admin")
public class AdminController 

    private final UserService userService;

    private final UserRoleService userRoleService;

    private final NoticeService noticeService;

    @GetMapping("/getUser")
    @ApiOperation("获取用户信息,可分页 ----> 查询条件(可无)(username,trueName),必须有的(pageNo,pageSize)")
    public CommonResult<PageResponse<UserInfoVo>> getUser(@RequestParam(required = false) String loginName,
                                                          @RequestParam(required = false) String trueName,
                                                          Integer pageNo, Integer pageSize) 
        return CommonResult.<PageResponse<UserInfoVo>>builder()
                .data(userService.getUser(loginName, trueName, pageNo, pageSize))
                .build();
    

    @GetMapping("/handleUser/type")
    @ApiOperation("管理员操作用户: type=1(启用) 2(禁用) 3(删除) userIds(需要操作的用户id)")
    public CommonResult<Void> handleUser(@PathVariable("type") Integer type, String userIds) 
        userService.handlerUser(type, userIds);
        return CommonResult.<Void>builder().build();
    

    @PostMapping("/addUser")
    @ApiOperation("管理员用户新增用户")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "user", value = "系统用户实体", required = true, dataType = "user", paramType = "body")
    )
    public CommonResult<Void> addUser(@RequestBody @Valid AddUserDto userDto) 
        userService.addUser(userDto);
        return CommonResult.<Void>builder().build();
    

    @GetMapping("/getRole")
    @ApiOperation("查询系统存在的所有角色信息")
    public CommonResult<List<UserRole>> getRole() 
        return CommonResult.<List<UserRole>>builder()
                .data(userRoleService.getUserRole())
                .build();
    

    @GetMapping("/getAllNotice")
    @ApiOperation("获取系统发布的所有公告(分页 条件查询  二合一接口)")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "noticeContent", value = "搜索公告内容", dataType = "string", paramType = "query"),
            @ApiImplicitParam(name = "pageNo", value = "查询结果分页当前页面", required = true, dataType = "int", paramType = "query"),
            @ApiImplicitParam(name = "pageSize", value = "查询结果的页面条数大小", required = true, dataType = "int", paramType = "query")
    )
    public CommonResult<PageResponse<Notice>> getAllNotice(@RequestParam(required = false, name = "noticeContent") String content,
                                                           Integer pageNo, Integer pageSize) 
        return CommonResult.<PageResponse<Notice>>builder()
                .data(noticeService.getAllNotices(content, pageNo, pageSize))
                .build();
    

    @PostMapping("/publishNotice")
    @ApiOperation("发布新公告")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "notice", value = "通知实体对象", required = true, dataType = "notice", paramType = "body")
    )
    public CommonResult<Void> publishNotice(@RequestBody Notice notice) 
        noticeService.publishNotice(notice);
        return CommonResult.<Void>builder()
                .build();
    

    @GetMapping("/deleteNotice")
    @ApiOperation("批量删除公告")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "noticeIds", value = "系统公告id", required = true, dataType = "string", paramType = "query")
    )
    public CommonResult<Void> deleteNotice(@RequestParam(name = "ids") String noticeIds) 
        noticeService.deleteNoticeByIds(noticeIds);
        return CommonResult.<Void>builder().build();
    

    @PostMapping("/updateNotice")
    @ApiOperation("更新公告")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "notice", value = "通知实体对象", required = true, dataType = "notice", paramType = "body")
    )
    public CommonResult<Void> updateNotice(@RequestBody Notice notice) 
        noticeService.updateNotice(notice);
        return CommonResult.<Void>builder().build();

package com.wzz.controller;

import com.wzz.entity.ExamQuestion;
import com.wzz.entity.ExamRecord;
import com.wzz.service.ExamQuestionService;
import com.wzz.service.QuestionService;
import com.wzz.service.impl.ExamRecordServiceImpl;
import com.wzz.vo.CommonResult;
import com.wzz.vo.PageResponse;
import com.wzz.vo.QuestionVo;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @author by znz
 * @implNote 2021/11/7 19:44
 */
@Slf4j
@RestController
@RequiredArgsConstructor
@Api(tags = "学生权限相关的接口")
@RequestMapping(value = "/student")
public class StudentController 

    private final ExamRecordServiceImpl examRecordService;

    private final QuestionService questionService;

    private final ExamQuestionService examQuestionService;

    @GetMapping("/getMyGrade")
    @ApiOperation("获取个人成绩(分页 根据考试名查询)")
    @ApiImplicitParams(@ApiImplicitParam(name = "username", value = "系统唯一用户名", required = true, dataType = "string", paramType = "query"), @ApiImplicitParam(name = "pageNo", value = "当前页面数", required = true, dataType = "int", paramType = "query"), @ApiImplicitParam(name = "pageSize", value = "当前页面大小", required = true, dataType = "int", paramType = "query"), @ApiImplicitParam(name = "examId", value = "考试唯一id", dataType = "int", paramType = "query"))
    public CommonResult<PageResponse<ExamRecord>> getMyGrade(String username, Integer pageNo, Integer pageSize, @RequestParam(required = false) Integer examId) 
        return CommonResult.<PageResponse<ExamRecord>>builder().data(examRecordService.getUserGrade(username, examId, pageNo, pageSize)).build();
    

    @GetMapping("/getCertificate")
    @ApiOperation("生成证书接口")
    @ApiImplicitParams(@ApiImplicitParam(name = "examName", value = "考试名称", required = true, dataType = "string", paramType = "query"), @ApiImplicitParam(name = "examRecordId", value = "考试记录id", required = true, dataType = "int", paramType = "query"))
    public void getCertificate(HttpServletResponse response, @RequestParam(name = "examName") String examName, @RequestParam(name = "examRecordId") Integer examRecordId) 
        examRecordService.createExamCertificate(response, examName, examRecordId);
    

    @PostMapping("/addExamRecord")
    @ApiOperation("保存考试记录信息,返回保存记录的id")
    @ApiImplicitParams(@ApiImplicitParam(name = "examRecord", value = "考试记录实体对象", required = true, dataType = "examRecord", paramType = "body"))
    public CommonResult<Integer> addExamRecord(@RequestBody ExamRecord examRecord, HttpServletRequest request) 
        return CommonResult.<Integer>builder().data(examRecordService.addExamRecord(examRecord, request)).build();
    

    // TODO 优化成多id一次查询
    @GetMapping("/getQuestionById/id")
    @ApiOperation("根据id获取题目信息")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "id", value = "问题id", required = true, dataType = "int", paramType = "path")
    )
    public CommonResult<QuestionVo> getQuestionById(@PathVariable("id") Integer id) 
        return CommonResult.<QuestionVo>builder()
                .data(questionService.getQuestionVoById(id))
                .build();
    

    @GetMapping("/getExamRecordById/recordId")
    @ApiOperation("根据考试的记录id查询用户考试的信息")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "recordId", value = "考试记录id", required = true, dataType = "int", paramType = "query")
    )
    public CommonResult<ExamRecord> getExamRecordById(@PathVariable Integer recordId) 
        return CommonResult.<ExamRecord>builder()
                .data(examRecordService.getExamRecordById(recordId))
                .build();
    

    @GetMapping("/getExamQuestionByExamId/examId")
    @ApiOperation("根据考试id查询考试中的每一道题目id和分值")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "examId", value = "考试id", required = true, dataType = "int", paramType = "query")
    )
    public CommonResult<ExamQuestion> getExamQuestionByExamId(@PathVariable Integer examId) 
        return CommonResult.<ExamQuestion>builder()
                .data(examQuestionService.getExamQuestionByExamId(examId))
                .build();

package com.wzz.controller;

import com.wzz.entity.ExamRecord;
import com.wzz.entity.Question;
import com.wzz.entity.QuestionBank;
import com.wzz.service.*;
import com.wzz.utils.OSSUtil;
import com.wzz.vo.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.validation.Valid;
import java.util.List;

/**
 * @author wzz
 * @implNote 2021/10/24 15:42
 */
@Slf4j
@Validated
@RestController
@RequiredArgsConstructor
@Api(tags = "老师权限相关的接口")
@RequestMapping(value = "/teacher")
public class TeacherController 

    private final ExamService examService;

    private final UserService userService;

    private final QuestionService questionService;

    private final ExamRecordService examRecordService;

    private final QuestionBankService questionBankService;

    @GetMapping("/getQuestionBank")
    @ApiOperation("获取所有题库信息")
    public CommonResult<List<QuestionBank>> getQuestionBank() 
        return CommonResult.<List<QuestionBank>>builder()
                .data(questionBankService.getAllQuestionBanks())
                .build();
    

    @GetMapping("/getQuestion")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "questionType", value = "问题类型", dataType = "string", paramType = "query"),
            @ApiImplicitParam(name = "questionBank", value = "问题所属题库", dataType = "string", paramType = "query"),
            @ApiImplicitParam(name = "questionContent", value = "问题内容", dataType = "string", paramType = "query"),
            @ApiImplicitParam(name = "pageNo", value = "页面数", required = true, dataType = "int", paramType = "query"),
            @ApiImplicitParam(name = "pageSize", value = "页面大小", required = true, dataType = "int", paramType = "query")
    )
    @ApiOperation("获取题目信息,可分页 ----> 查询条件(可无)(questionType,questionBank,questionContent),必须有的(pageNo,pageSize)")
    public CommonResult<PageResponse<Question>> getQuestion(@RequestParam(required = false) String questionType,
                                                            @RequestParam(required = false) String questionBank,
                                                            @RequestParam(required = false) String questionContent,
                                                            Integer pageNo, Integer pageSize) 
        return CommonResult.<PageResponse<Question>>builder()
                .data(questionService.getQuestion(questionType, questionBank, questionContent, pageNo, pageSize))
                .build();
    

    @GetMapping("/deleteQuestion")
    @ApiOperation("根据id批量删除")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "questionIds", value = "问题id的字符串以逗号分隔", required = true, dataType = "string", paramType = "query")
    )
    public CommonResult<Void> deleteQuestion(String questionIds) 
        questionService.deleteQuestionByIds(questionIds);
        return CommonResult.<Void>builder()
                .build();
    

    @GetMapping("/addBankQuestion")
    @ApiOperation("将问题加入题库")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "questionIds", value = "问题id的字符串以逗号分隔", required = true, dataType = "string", paramType = "query"),
            @ApiImplicitParam(name = "banks", value = "题库id的字符串以逗号分隔", required = true, dataType = "string", paramType = "query")
    )
    public CommonResult<String> addBankQuestion(String questionIds, String banks) 
        questionBankService.addQuestionToBank(questionIds, banks);
        return CommonResult.<String>builder()
                .build();
    

    @GetMapping("/removeBankQuestion")
    @ApiOperation("将问题从题库移除")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "questionIds", value = "问题id的字符串以逗号分隔", required = true, dataType = "string", paramType = "query"),
            @ApiImplicitParam(name = "banks", value = "题库id的字符串以逗号分隔", required = true, dataType = "string", paramType = "query")
    )
    public CommonResult<Void> removeBankQuestion(String questionIds, String banks) 
        questionBankService.removeBankQuestion(questionIds, banks);
        return CommonResult.<Void>builder()
                .build();
    

    @PostMapping("/uploadQuestionImage")
    @ApiOperation("接受前端上传的图片,返回上传图片地址")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "file", value = "图片文件", required = true, dataType = "file", paramType = "body")
    )
    public CommonResult<String> uploadQuestionImage(MultipartFile file) throws Exception 
        log.info("开始上传文件: ", file.getOriginalFilename());
        return CommonResult.<String>builder()
                .data(OSSUtil.picOSS(file))
                .message("上传成功")
                .build();
    

    @PostMapping("/addQuestion")
    @ApiOperation("添加试题")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "questionVo", value = "问题的vo视图对象", required = true, dataType = "questionVo", paramType = "body")
    )
    public CommonResult<Void> addQuestion(@RequestBody @Valid QuestionVo questionVo) 
        questionService.addQuestion(questionVo);
        return CommonResult.<Void>builder().build();
    

    @PostMapping("/updateQuestion")
    @ApiOperation("更新试题")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "questionVo", value = "问题的vo视图对象", required = true, dataType = "questionVo", paramType = "body")
    )
    public CommonResult<Void> updateQuestion(@RequestBody @Valid QuestionVo questionVo) 
        questionService.updateQuestion(questionVo);
        return CommonResult.<Void>builder()
                .build();
    

    @GetMapping("/deleteQuestionBank")
    @ApiOperation("删除题库并去除所有题目中的包含此题库的信息")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "ids", value = "删除题库的id字符串逗号分隔", required = true, dataType = "string", paramType = "query")
    )
    public CommonResult<Void> deleteQuestionBank(String ids) 
        questionBankService.deleteQuestionBank(ids);
        return CommonResult.<Void>builder()
                .build();
    

    @PostMapping("/addQuestionBank")
    @ApiOperation("添加题库信息")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "questionBank", value = "题库的实体对象", required = true, dataType = "questionBank", paramType = "body")
    )
    public CommonResult<Void> addQuestionBank(@RequestBody QuestionBank questionBank) 
        questionBankService.addQuestionBank(questionBank);
        return CommonResult.<Void>builder()
                .build();
    

    @GetMapping("/operationExam/type")
    @ApiOperation("操作考试的信息表(type 1启用 2禁用 3删除)")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "type", value = "操作类型", required = true, dataType = "int", paramType = "query"),
            @ApiImplicitParam(name = "ids", value = "操作的考试id集合", required = true, dataType = "string", paramType = "query")
    )
    public CommonResult<Void> operationExam(@PathVariable("type") Integer type, String ids) 
        examService.operationExam(type, ids);
        return CommonResult.<Void>builder()
                .build();
    

    @PostMapping("/addExamByBank")
    @ApiOperation("根据题库添加考试")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "addExamByBankVo", value = "根据题库添加考试vo对象", required = true, dataType = "addExamByBankVo", paramType = "body")
    )
    public CommonResult<Void> addExamByBank(@RequestBody @Valid AddExamByBankVo addExamByBankVo) 
        examService.addExamByBank(addExamByBankVo);
        return CommonResult.<Void>builder()
                .build();
    

    @PostMapping("/addExamByQuestionList")
    @ApiOperation("根据题目列表添加考试")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "addExamByQuestionVo", value = "通过题目列表添加考试的vo对象", required = true, dataType = "addExamByQuestionVo", paramType = "body")
    )
    public CommonResult<Void> addExamByQuestionList(@RequestBody @Valid AddExamByQuestionVo addExamByQuestionVo) 
        examService.addExamByQuestionList(addExamByQuestionVo);
        return CommonResult.<Void>builder()
                .build();
    

    @PostMapping("/updateExamInfo")
    @ApiOperation("更新考试的信息")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "addExamByQuestionVo", value = "通过题目列表添加考试的vo对象", required = true, dataType = "addExamByQuestionVo", paramType = "body")
    )
    public CommonResult<Void> updateExamInfo(@RequestBody AddExamByQuestionVo addExamByQuestionVo) 
        examService.updateExamInfo(addExamByQuestionVo);
        return CommonResult.<Void>builder()
                .build();
    

    @GetMapping("/getExamRecord")
    @ApiOperation("获取考试记录信息,(pageNo,pageSize)")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "examId", value = "考试id", required = true, dataType = "int", paramType = "query"),
            @ApiImplicitParam(name = "pageNo", value = "页面数", required = true, dataType = "int", paramType = "query"),
            @ApiImplicitParam(name = "pageSize", value = "页面大小", required = true, dataType = "int", paramType = "query")
    )
    public CommonResult<PageResponse<ExamRecord>> getExamRecord(@RequestParam(required = false) Integer examId, Integer pageNo, Integer pageSize) 
        return CommonResult.<PageResponse<ExamRecord>>builder()
                .data(examRecordService.getExamRecord(examId, pageNo, pageSize))
                .build();
    

    // TODO 改成ids查询
    @GetMapping("/getUserById/userId")
    @ApiOperation("根据用户id查询用户信息")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "userId", value = "用户id", required = true, dataType = "int", paramType = "query")
    )
    public CommonResult<UserInfoVo> getUserById(@PathVariable Integer userId) 
        return CommonResult.<UserInfoVo>builder()
                .data(userService.getUserInfoById(userId))
                .build();
    

    @GetMapping("/setObjectQuestionScore")
    @ApiOperation("设置考试记录的客观题得分,设置总分为逻辑得分+客观题")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "totalScore", value = "总成绩", required = true, dataType = "int", paramType = "query"),
            @ApiImplicitParam(name = "examRecordId", value = "考试记录id", required = true, dataType = "int", paramType = "query")
    )
    public CommonResult<Void> setObjectQuestionScore(Integer totalScore, Integer examRecordId) 
        examRecordService.setObjectQuestionScore(totalScore, examRecordId);
        return CommonResult.<Void>builder()
                .build();
    

    @GetMapping("/getExamPassRate")
    @ApiOperation("提供每一门考试的通过率数据(echarts绘图)")
    public CommonResult<List<String>> getExamPassRate() 
        return CommonResult.<List<String>>builder()
                .data(examService.getExamPassRateEchartData())
                .build();
    

    @GetMapping("/getExamNumbers")
    @ApiOperation("提供每一门考试的考试次数(echarts绘图)")
    public CommonResult<List<String>> getExamNumbers() 
        return CommonResult.<List<String>>builder()
                .data(examService.getExamNumbersEchartData())
                .build();

package com.wzz.controller;

import com.wzz.entity.Exam;
import com.wzz.service.ExamService;
import com.wzz.service.NoticeService;
import com.wzz.service.QuestionBankService;
import com.wzz.vo.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequiredArgsConstructor
@Api(tags = "三个角色公共的相关接口")
@RequestMapping(value = "/public")
public class PublicController 

    private final NoticeService noticeService;

    private final ExamService examService;

    private final QuestionBankService questionBankService;

    @PostMapping("/getExamInfo")
    @ApiOperation("根据信息查询考试的信息")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "examQueryVo", value = "考试信息查询vo对象", required = true, dataType = "examQueryVo", paramType = "body")
    )
    public CommonResult<PageResponse<Exam>> getExamInfo(@RequestBody ExamQueryVo examQueryVo) 
        return CommonResult.<PageResponse<Exam>>builder()
                .data(examService.getExamPage(examQueryVo))
                .build();
    

    @GetMapping("/getExamInfoById")
    @ApiOperation("根据考试id查询考试的信息和题目列表")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "examId", value = "考试id", required = true, dataType = "int", paramType = "query")
    )
    public CommonResult<AddExamByQuestionVo> getExamInfoById(@RequestParam Integer examId) 
        return CommonResult.<AddExamByQuestionVo>builder()
                .data(examService.getExamInfoById(examId))
                .build();
    

    @GetMapping("/allExamInfo")
    @ApiOperation("查询考试所有信息")
    public CommonResult<List<Exam>> allExamInfo() 
        return CommonResult.<List<Exam>>builder()
                .data(examService.list(null))
                .build();
    

    @GetMapping("/getBankHaveQuestionSumByType")
    @ApiOperation("获取题库中所有题目类型的数量")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "bankName", value = "题库名称", dataType = "string", paramType = "query"),
            @ApiImplicitParam(name = "pageNo", value = "页面数", required = true, dataType = "int", paramType = "query"),
            @ApiImplicitParam(name = "pageSize", value = "页面大小", required = true, dataType = "int", paramType = "query"),
    )
    public CommonResult<PageResponse<BankHaveQuestionSum>> getBankHaveQuestionSumByType(@RequestParam(required = false) String bankName,
                                                                                        Integer pageNo, Integer pageSize) 
        return CommonResult.<PageResponse<BankHaveQuestionSum>>builder()
                .data(questionBankService.getBankHaveQuestionSumByType(bankName, pageNo, pageSize))
                .build();
    

    @GetMapping("/getQuestionByBankIdAndType")
    @ApiOperation("根据题库id和题目类型获取题目信息 type(1单选 2多选 3判断)")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "bankId", value = "题库id", required = true, dataType = "int", paramType = "query"),
            @ApiImplicitParam(name = "type", value = "题目类型", required = true, dataType = "int", paramType = "query"),
    )
    public CommonResult<List<QuestionVo>> getQuestionByBankIdAndType(Integer bankId, Integer type) 
        return CommonResult.<List<QuestionVo>>builder()
                .data(questionBankService.getQuestionByBankIdAndType(bankId, type))
                .build();
    

    @GetMapping("/getQuestionByBank")
    @ApiOperation("根据题库获取所有的题目信息(单选,多选,判断题)")
    @ApiImplicitParams(
            @ApiImplicitParam(name = "bankId", value = "题库id", required = true, dataType = "int", paramType = "query")
    )
    public CommonResult<List<QuestionVo>> getQuestionByBank(Integer bankId) 
        return CommonResult.<List<QuestionVo>>builder()
                .data(questionBankService.getQuestionsByBankId(bankId))
                .build();
    

    @GetMapping("/getCurrentNewNotice")
    @ApiOperation("获取当前系统最新的公告")
    public CommonResult<String> getCurrentNewNotice() 
        return CommonResult.<String>builder()
                .data(noticeService.getCurrentNotice())
                .build();

以上是关于Springboot+vue前后端分离考试系统的主要内容，如果未能解决你的问题，请参考以下文章

Springboot+vue前后端分离考试系统

Springboot+vue实现前后端分离智能化考试系统

java毕设项目开源了，springboot+vue的学生考试系统

SpringBoot+Vue+AntDesign前后端分离通用后台管理系统

最棒的SpringBoot+Vue+AntDesign前后端分离系统搭建教程