毕业设计 : 基于springboot+vue的在线考试系统

文章目录

前言
1 系统开发目的
2 技术栈
3 项目结构
4 项目部署方法
5 系统设计
- 6.1 ER图
- 6.2 系统功能模块
- - 6.2.1 考生模块：
  - 6.2.2 教师模块：
- 6.3 代码实现
- - 6.3.1 工程结构
  - 6.3.2 系统配置
- 6.4 业务代码
7 项目展示
- 7.1 用户端
- 7.2 后台管理系统
8 最后-毕设帮助

前言

Hi，同学们好呀，被评为全网最细的丹成学长ヾ(•ω•`)o，今天带大家复盘一个学长帮往届同学做的一个毕业作品

基于springboot+vue的在线考试系统

需要毕设帮助的同学，看过来~
毕设帮助，开题指导，技术解答
746876041

1 系统开发目的

面向组织、公司、高校的一款通用在线考试系统，节约人力财力，轻松完成在线考核。系统拥有自行添加题库，考试随机抽题，线上监考，自动阅卷评分，实现了无纸化考试，自动化阅卷等功能。

2 技术栈

基本平台：JDK1.8+MySql8.0
前端：Vue2+Axios+ElementUI+echart
后端：SpringBoot+MyBatis+SpringSecurity+easyPoi+Jwt
基于RBAC权限模型（用户、角色、权限）

3 项目结构

|----bin 完整项目成品（一键部署）
|----image 项目运行截图
|----sql 数据库文件
|----voes-admin Springboot核心模块
|----voes-common 公共模块
|----voes-examination 考试模块
|----voes-framework 框架模块
|----voes-system 系统模块
|----voes-ui 前端界面

4 项目部署方法

1.将sql目录下的sql文件导入mysql数据库;
2.将项目导入IDEA开发工具，执行voes-admin模块目录下的main方法，启动SpringBoot服务;
3.进入voes-ui目录下执行 npm run dev即可启动前端UI服务;

一键安装：

1.将sql目录下的sql文件导入mysql数据库;
2.将bin目录下的文件移动到你的服务器上，点击start.bat即可启动服务;

5 系统设计 6.1 ER图

6.2 系统功能模块

6.2.1 考生模块：

（1）在线考试：考生在规定时间里选择考试科目，进行考试。
（2）历史考试：考生可以查看历史考试的信息信息。
（3）修改密码：考生可以修改自己的登录密码。
（4）账户信息：考生可以修改的真实姓名和手机号码。

6.2.2 教师模块：

（1）系统设置：教师可以进行菜单管理添加、编辑、删除，角色管理添加、编辑、删除，修改密码。
（2）用户管理：教师可以进行用户列表的添加、编辑、删除。
（3）系统日志：教师可以进行日志列表的添加、删除。
（4）学科管理：教师可以进行学科列表的添加、编辑、删除。
（5）考生管理：教师可以进行考生列表的添加、编辑、删除。
（6）试题管理：教师可以进行试题列表的添加、编辑、删除，批量导入试题。
（7）考试管理：教师可以进行考试列表的添加、编辑、删除。
（8）试卷管理：教师可以进行试卷列表的编辑、删除。
（9）答题管理：教师可以进行学生答题情况的查询。
（10）成绩统计：教师可以进行查看考试的成绩统计图表。

6.3 代码实现 6.3.1 工程结构

6.3.2 系统配置

server:
  port: 8080
#  ssl:
#    key-store: classpath:keystore.p12
#    key-store-password: qwertyuiop
#    key-store-type: PKCS12
#    key-alias: tomcat
spring:
  jackson:
    time-zone: GMT+8
    date-format: com.fasterxml.jackson.databind.util.StdDateFormat
  application:
    name: voes
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/voes?useSSL=false&serverTimezone=Asia/Shanghai&characterEncoding=utf8
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: 123456
    type: com.alibaba.druid.pool.DruidDataSource
    #   数据源其他配置
    initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECt 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true
    #   配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
    filters: stat,wall
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
  servlet:
    multipart:
      max-file-size: 1024MB
  main:
    allow-bean-definition-overriding: true
# token配置
token:
  # 令牌自定义标识
  header: Authorization
  # 令牌密钥
  secret: abcdefghijklmnopqrstuvwxyz
  # 令牌有效期（默认60分钟）
  expireTime: 60
mybatis:
  mapper-locations: classpath*:/mapper*.xml
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

6.4 业务代码

 
    @Override
    public QuestionBank queryById(Integer id, boolean answer) {
        Integer type = questionBankMapper.queryTypeById(id);
        //单选题
        if (QuestionType.SINGLE_CHOICE.equals(type)) {
            log.info("单选题");
            QuestionBank questionBank = questionBankMapper.queryByIdWithOption(id);
            QuestionOption questionOption = questionBank.getQuestionOption();
            if (!answer) {
                questionOption.setRightKey(null);
                questionOption.setExplain(null);
            }
            return questionBank;
        }
        //多选题
        if (QuestionType.MULTIPLE_CHOICE.equals(type)) {
            log.info("多选题");
            QuestionBank questionBank = questionBankMapper.queryByIdWithOption(id);
            QuestionOption questionOption = questionBank.getQuestionOption();
            if (!answer) {
                questionOption.setRightKey(null);
                questionOption.setExplain(null);
            }
            return questionBank;

        }
        //填空题
        if (QuestionType.FILL_IN_THE_BLANKS.equals(type)) {
            log.info("填空题");
            QuestionBank questionBank = questionBankMapper.queryByIdWithFill(id);

            QuestionFillBlanks questionFillBlank = questionBank.getQuestionFillBlank();
            if (!answer) {
                questionFillBlank.setAnswer(null);
            }
            return questionBank;
        }
        //判断题
        if (QuestionType.JUDGE.equals(type)) {
            log.info("判断题");
            QuestionBank questionBank = questionBankMapper.queryByIdWithJudgment(id);

            if (!answer) {
                QuestionJudgment questionJudgment = questionBank.getQuestionJudgment();
                questionJudgment.setRightKey(null);
                questionJudgment.setExplain(null);
            }

            return questionBank;
        }
        //主观题目
        //与填空题保持一致
        if (QuestionType.SUBJECTIVE.equals(type)) {
            log.info("主观题");
            QuestionBank questionBank = questionBankMapper.queryByIdWithFill(id);
            QuestionFillBlanks questionFillBlank = questionBank.getQuestionFillBlank();
            if (!answer) {
                questionFillBlank.setAnswer(null);
            }
            return questionBank;
        }

        return null;
    }

    @Override
    public QuestionBank queryById(Integer id) {
        return queryById(id, true);
    }


    
    @Override
    public List queryAllByLimit(int offset, int limit) {
        return this.questionBankMapper.queryAllByLimit(offset, limit);
    }

    
    @Override
    public PageInfo queryAll(QuestionBank questionBank, int currentPage, int pageSize) {
        PageHelper.startPage(currentPage, pageSize);
        List questionBanks = questionBankMapper.queryAll(questionBank);
        return new PageInfo(questionBanks);
    }

    
    @Override
    public QuestionBank insert(QuestionBank questionBank) {
        Integer type = questionBank.getType();
        //插入题库
        questionBankMapper.insert(questionBank);
        Integer primary = questionBank.getId();

        //插入答案

        //单选题
        if (QuestionType.SINGLE_CHOICE.equals(type)) {
            QuestionOption questionOption = questionBank.getQuestionOption();
            questionOption.setQuestionBankId(primary);
            questionOptionMapper.insert(questionOption);
        }
        //多选题
        if (QuestionType.MULTIPLE_CHOICE.equals(type)) {
            QuestionOption questionOption = questionBank.getQuestionOption();
            questionOption.setQuestionBankId(primary);
            questionOptionMapper.insert(questionOption);
        }
        //填空题
        if (QuestionType.FILL_IN_THE_BLANKS.equals(type)) {
            QuestionFillBlanks questionFillBlank = questionBank.getQuestionFillBlank();
            questionFillBlank.setQuestionBankId(primary);
            questionFillBlanksMapper.insert(questionFillBlank);
        }
        //判断题
        if (QuestionType.JUDGE.equals(type)) {
            QuestionJudgment questionJudgment = questionBank.getQuestionJudgment();
            questionJudgment.setQuestionBankId(primary);
            questionJudgmentMapper.insert(questionJudgment);
        }
        //主观题
        //等于填空题
        if (QuestionType.SUBJECTIVE.equals(type)) {
            QuestionFillBlanks questionFillBlank = questionBank.getQuestionFillBlank();
            questionFillBlank.setQuestionBankId(primary);
            questionFillBlanksMapper.insert(questionFillBlank);
        }
        return questionBank;
    }

    
    @Override
    public QuestionBank update(QuestionBank questionBank) {
        //题编号
        Integer id = questionBank.getId();
        //题型
        Integer type = questionBank.getType();
        //单选题
        if (QuestionType.SINGLE_CHOICE.equals(type)) {
            QuestionOption questionOption = questionBank.getQuestionOption();
            questionOption.setQuestionBankId(id);
            questionOptionMapper.update(questionOption);
        }
        //多选题
        if (QuestionType.MULTIPLE_CHOICE.equals(type)) {
            QuestionOption questionOption = questionBank.getQuestionOption();
            questionOption.setQuestionBankId(id);
            questionOptionMapper.update(questionOption);
        }
        //填空题
        if (QuestionType.FILL_IN_THE_BLANKS.equals(type)) {
            QuestionFillBlanks questionFillBlank = questionBank.getQuestionFillBlank();
            questionFillBlank.setQuestionBankId(id);
            questionFillBlanksMapper.update(questionFillBlank);
        }
        //判断题
        if (QuestionType.JUDGE.equals(type)) {
            QuestionJudgment questionJudgment = questionBank.getQuestionJudgment();
            questionJudgment.setQuestionBankId(id);
            questionJudgmentMapper.update(questionJudgment);
        }
        //主观题
        //等于填空题
        if (QuestionType.SUBJECTIVE.equals(type)) {
            QuestionFillBlanks questionFillBlank = questionBank.getQuestionFillBlank();
            questionFillBlank.setQuestionBankId(id);
            questionFillBlanksMapper.update(questionFillBlank);
        }
        questionBankMapper.update(questionBank);
        return this.queryById(questionBank.getId());
    }

    
    @Override
    public boolean deleteById(Integer id) {
        //删除答卷上面的题
        testPaperMapper.deleteByQuestionBankId(id);
        scoreMapper.deleteByQuestionBankId(id);
        //先删除答案
        //再删除题
        QuestionBank questionBank = questionBankMapper.queryById(id);
        Integer type = questionBank.getType();
        //单选题
        if (QuestionType.SINGLE_CHOICE.equals(type)) {
            questionOptionMapper.deleteByQuestionBankId(id);
        }
        //多选题
        if (QuestionType.MULTIPLE_CHOICE.equals(type)) {
            questionOptionMapper.deleteByQuestionBankId(id);
        }
        //填空题
        if (QuestionType.FILL_IN_THE_BLANKS.equals(type)) {
            questionFillBlanksMapper.deleteByQuestionBankId(id);
        }
        //判断题
        if (QuestionType.JUDGE.equals(type)) {
            questionJudgmentMapper.deleteByQuestionBankId(id);
        }
        //主观题
        if (QuestionType.SUBJECTIVE.equals(type)) {
            questionFillBlanksMapper.deleteByQuestionBankId(id);
        }
        return questionBankMapper.deleteById(id) > 0;
    }

    @Override
    public boolean deleteByIds(List ids) {
        if (ids != null && ids.size() > 0) {
            ids.forEach(id -> {
                boolean b = this.deleteById(id);
            });
        }
        return true;
    }

3.4控制层代码
@Autowired
QuestionBankService questionBankService;


@RequestMapping("/questionBanks")
public AjaxResult list(
        QuestionBank questionBank,
        @RequestParam(defaultValue = "1") int currentPage,
        @RequestParam(defaultValue = "10") int pageSize) {
    PageInfo questionBankPageInfo = questionBankService.queryAll(questionBank, currentPage, pageSize);
    return AjaxResult.success(questionBankPageInfo);
}

@RequestMapping("/get/{id}")
public AjaxResult list(@PathVariable int id) {
    QuestionBank questionBank = questionBankService.queryById(id);
    return AjaxResult.success(questionBank);
}

//    下面的记得添加权限
@RequestMapping("/add")
public AjaxResult add(@Valid @RequestBody QuestionBank questionBank) {
    QuestionBank insert = questionBankService.insert(questionBank);
    return AjaxResult.success(insert);
}

@RequestMapping("/update")
public AjaxResult update(@Valid @RequestBody QuestionBank questionBank) {
    QuestionBank insert = questionBankService.update(questionBank);
    return AjaxResult.success(insert);
}

@RequestMapping("/delete")
public AjaxResult delete(Integer id) {
    boolean flag = questionBankService.deleteById(id);
    return AjaxResult.success(flag);
}

@RequestMapping("/deletes")
public AjaxResult deletes(IdsVo idsVo) {
    List ids = idsVo.getIds();
    questionBankService.deleteByIds(ids);
    return AjaxResult.success();
}

@RequestMapping("/searchCount")
public AjaxResult searchCount(String keyWord) {
    Map map = questionBankService.searchCount(keyWord);
    return AjaxResult.success(map);
}

7 项目展示

注意：项目内采用的logo、图片等素材均来源于网络，数据均是模拟测试数据。

7.1 用户端

主页

考试管理

报名成功

我的考试

查看成绩

考试页面

考场实时监控平台

7.2 后台管理系统

考试管理

题库管理

用户管理

查看试卷

随机抽题

8 最后-毕设帮助

毕设帮助，开题指导，技术解答
746876041

文章版权说明：

该文章由丹成学长全网第一时间发布，CSDN: mathor-sinor，上述系统为丹成学长开发完成，违版必究，如有项目开发需求请联系丹成学长.

毕业设计 : 基于springboot+vue的在线考试系统 - SSM Vue.js

Java相关栏目本月热门文章