基于Springboot实现在线考试管理系统

项目编号：BS-XX-067

 

运行环境：

开发工具：IDEA / ECLIPSE

数据库：MYSQL5.7+Redis

应用服务器：TOMCAT8.5.31

JDK:1.8

后台开发技术：Springboot+mybatis+springmvc

前台开发技术：Jquery+Bootstrap

     本项目基于Springboot开发实现一套在线考试及试题管理系统。基本上完成了在线考试系统所需要的相应基本功能。系统基本功能完整，有部分小功能未实现，基本上完成从出题到组卷再到考试以及批改试卷成绩的全过程。另外界面设计美观大方，操作方便，交互性好，这是本项目的优势。比较适合做毕业设计使用。

系统共分三个角色：

   管理员：可以管理学生信息、教师信息、考试信息、课程信息、成绩信息、讨论区的贴子及回贴管理

   老师：主要进入系统后可以管理自己所担任课程的试题、考试、课程、批改试卷等操作

  学生：进入系统后可以参加考试，查看自己的考试成绩，可以查看自己所属学科的试题等。

下面具体展示一下系统的相关功能：

以管理员身份进入演示所有的功能展示，实际项目可以以学生、教师、助教进入系统后实施不同的操作。

系统前端首页

登陆页面

管理员登陆系统后

考试管理

试题管理

课程管理

所上课程的班级管理

为所在班级添加学生

上传课程教学大纲

课程调查问卷管理

成绩管理

学生管理

助教管理

教师管理

讨论区贴子管理

评论管理

个人信息管理：

前端功能展示：

在线考试

参加考试

题库中心复习

讨论区论坛版块

基于篇幅限制，只演示一下系统的部分功能，应该来说系统的整体功能还是非常完整，界面设计也很优雅，操作也十分方便，是一个难得的优秀毕业设计系统。

部分功能实现代码：

package com.ctgu.service.impl;

import com.github.pagehelper.PageHelper;
import com.ctgu.common.Const;
import com.ctgu.dao.AccountMapper;
import com.ctgu.model.Account;
import com.ctgu.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;

@Service("accountService")
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountMapper accountMapper;

    @Override
    public int addAccount(Account account) {
        account.setAvatarImgUrl(Const.DEFAULT_AVATAR_IMG_URL);
        return accountMapper.insertAccount(account);
    }

    @Override
    public boolean updateAccount(Account account) {
        return accountMapper.updateAccountById(account) > 0;
    }

    @Override
    public boolean updateAvatarImgUrlById(String avatarImgUrl, int id) {
        return accountMapper.updateAvatarImgUrlById(avatarImgUrl, id) > 0;
    }

    @Override
    public Account getAccountByUsername(String username) {
        return accountMapper.getAccountByUsername(username);
    }

    @Override
    public List<Account> getAccountsByStudentIds(List<Integer> studentIds) {
        return accountMapper.getAccountsByIds(studentIds);
    }

    @Override
    public Map<String, Object> getAccounts(int pageNum, int pageSize) {
        Map<String, Object> data = new HashMap<>();
        int count = accountMapper.getCount();
        if (count == 0) {
            data.put("pageNum", 0);
            data.put("pageSize", 0);
            data.put("totalPageNum", 1);
            data.put("totalPageSize", 0);
            data.put("accounts", new ArrayList<>());
            return data;
        }
        int totalPageNum = count % pageSize == 0 ? count / pageSize : count / pageSize + 1;
        if (pageNum > totalPageNum) {
            data.put("pageNum", 0);
            data.put("pageSize", 0);
            data.put("totalPageNum", totalPageNum);
            data.put("totalPageSize", 0);
            data.put("accounts", new ArrayList<>());
            return data;
        }
        PageHelper.startPage(pageNum, pageSize);
        List<Account> accounts = accountMapper.getAccounts();
        data.put("pageNum", pageNum);
        data.put("pageSize", pageSize);
        data.put("totalPageNum", totalPageNum);
        data.put("totalPageSize", count);
        data.put("accounts", accounts);
        return data;
    }

    @Override
    public Map<String, Object> getAccountsByLevel(int pageNum, int pageSize, int level) {
        Map<String, Object> data = new HashMap<>();
        int count = accountMapper.getCountByLevel(level);
        if (count == 0) {
            data.put("pageNum", 0);
            data.put("pageSize", 0);
            data.put("totalPageNum", 1);
            data.put("totalPageSize", 0);
            data.put("accounts", new ArrayList<>());
            return data;
        }
        int totalPageNum = count % pageSize == 0 ? count / pageSize : count / pageSize + 1;
        if (pageNum > totalPageNum) {
            data.put("pageNum", 0);
            data.put("pageSize", 0);
            data.put("totalPageNum", totalPageNum);
            data.put("totalPageSize", 0);
            data.put("accounts", new ArrayList<>());
            return data;
        }
        PageHelper.startPage(pageNum, pageSize);
        List<Account> accounts = accountMapper.getAccountsByLevel(level);
        data.put("pageNum", pageNum);
        data.put("pageSize", pageSize);
        data.put("totalPageNum", totalPageNum);
        data.put("totalPageSize", count);
        data.put("accounts", accounts);
        return data;
    }

    @Override
    public boolean deleteAccount(int id) {
        return accountMapper.deleteAccount(id) > 0;
    }

    @Override
    public boolean disabledAccount(int id) {
        return accountMapper.updateState(id, 1) > 0;
    }

    @Override
    public boolean abledAccount(int id) {
        return accountMapper.updateState(id, 0) > 0;
    }

    @Override
    public List<Account> getAccountsByIds(Set<Integer> ids) {
        return accountMapper.getAccountsByIdSets(ids);
    }

    @Override
    public Account getAccountById(int id) {
        return accountMapper.getAccountById(id);
    }

    @Override
    public List<Account> getAccountsByLevel(int teacherLevel) {
        return accountMapper.getAccountsByLevel(teacherLevel);
    }
}

package com.ctgu.service.impl;

import com.ctgu.dao.ClassMapper;
import com.ctgu.service.ContestService;
import com.github.pagehelper.PageHelper;
import com.ctgu.dao.ContestMapper;
import com.ctgu.dao.SubjectMapper;
import com.ctgu.model.Contest;
import com.ctgu.model.Subject;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

@Service("contestService")
public class ContestServiceImpl implements ContestService {

    private static Log LOG = LogFactory.getLog(ContestServiceImpl.class);

    @Autowired
    private ContestMapper contestMapper;
    @Autowired
    private SubjectMapper subjectMapper;
    @Autowired
    private ClassMapper classMapper;

    @Override
    public int addContest(Contest contest) {
        contest.setTotalScore(0);
        contest.setState(0);
        return contestMapper.insertContest(contest);
    }

    @Override
    public boolean updateContest(Contest contest) {
        return contestMapper.updateContestById(contest) > 0;
    }

    @Override
    public Contest getContestById(int id) {
        return contestMapper.getContestById(id);
    }

    @Override
    public Map<String, Object> getContests(int pageNum, int pageSize) {
        Map<String, Object> data = new HashMap<>();
        int count = contestMapper.getCount();
        if (count == 0) {
            data.put("pageNum", 0);
            data.put("pageSize", 0);
            data.put("totalPageNum", 1);
            data.put("totalPageSize", 0);
            data.put("contests", new ArrayList<>());
            return data;
        }
        int totalPageNum = count % pageSize == 0 ? count / pageSize : count / pageSize + 1;
        if (pageNum > totalPageNum) {
            data.put("pageNum", 0);
            data.put("pageSize", 0);
            data.put("totalPageNum", totalPageNum);
            data.put("totalPageSize", 0);
            data.put("contests", new ArrayList<>());
            return data;
        }
        List<Subject> subjects = subjectMapper.getSubjects();
        PageHelper.startPage(pageNum, pageSize);
        List<Contest> contests = contestMapper.getContests();
        System.out.println(contests);
        Map<Integer, String> subjectId2name = subjects.stream().
                collect(Collectors.toMap(Subject::getId, Subject::getName));
        for (Contest contest : contests) {
            contest.setSubjectName(subjectId2name.
                    getOrDefault(contest.getSubjectId(), "未知科目"));
        }
        data.put("pageNum", pageNum);
        data.put("pageSize", pageSize);
        data.put("totalPageNum", totalPageNum);
        data.put("totalPageSize", count);
        data.put("contests", contests);

        return data;
    }

    @Override
    public boolean deleteContest(int id) {
        return contestMapper.deleteContest(id) > 0;
    }

    @Override
    public boolean updateStateToStart() {
        return contestMapper.updateStateToStart(new Date()) > 0;
    }

    @Override
    public boolean updateStateToEnd() {
        return contestMapper.updateStateToEnd(new Date()) > 0;
    }

    @Override
    public List<Contest> getContestsByContestIds(Set<Integer> contestIds) {
        return contestMapper.getContestsByContestIds(contestIds);
    }

    public Map<String, Object> getContestsByAccountId(int pageNum, int pageSize, int id) {
        Map<String, Object> data = new HashMap<>();
        int count = contestMapper.getCount();
        if (count == 0) {
            data.put("pageNum", 0);
            data.put("pageSize", 0);
            data.put("totalPageNum", 1);
            data.put("totalPageSize", 0);
            data.put("contests", new ArrayList<>());
            return data;
        }
        int totalPageNum = count % pageSize == 0 ? count / pageSize : count / pageSize + 1;
        if (pageNum > totalPageNum) {
            data.put("pageNum", 0);
            data.put("pageSize", 0);
            data.put("totalPageNum", totalPageNum);
            data.put("totalPageSize", 0);
            data.put("contests", new ArrayList<>());
            return data;
        }

        List<Subject> subjects = subjectMapper.getSubjects();
        PageHelper.startPage(pageNum, pageSize);
        //List<Contest> contests = contestMapper.getContests();
        List<Contest> contests = new ArrayList<>();

        List<Integer> subjectIds = classMapper.getSubjectIdsByAccountId(id);
        for (Integer subjectId : subjectIds) {
            List<Contest> contestList = contestMapper.getContestsBySubjectId(subjectId);
            contests.addAll(contestList);
        }
        Map<Integer, String> subjectId2name = subjects.stream().
                collect(Collectors.toMap(Subject::getId, Subject::getName));
        for (Contest contest : contests) {
            contest.setSubjectName(subjectId2name.
                    getOrDefault(contest.getSubjectId(), "未知科目"));
        }

        data.put("pageNum", pageNum);
        data.put("pageSize", pageSize);
        data.put("totalPageNum", totalPageNum);
        data.put("totalPageSize", count);
        data.put("contests", contests);

        return data;
    }
}

package com.ctgu.service.impl;

import com.github.pagehelper.PageHelper;
import com.ctgu.dao.GradeMapper;
import com.ctgu.model.Grade;
import com.ctgu.service.GradeService;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service("gradeService")
public class GradeServiceImpl implements GradeService {

    private static Log LOG = LogFactory.getLog(GradeServiceImpl.class);

    @Autowired
    private GradeMapper gradeMapper;

    @Override
    public int addGrade(Grade grade) {
        return gradeMapper.insertGrade(grade);
    }

    @Override
    public boolean updateGrade(Grade grade) {
        return gradeMapper.updateGradeById(grade) > 0;
    }

    @Override
    public boolean deleteGrade(int id) {
        return gradeMapper.deleteGrade(id) > 0;
    }

    @Override
    public Grade getGradeById(int id) {
        return gradeMapper.getGradeById(id);
    }

    @Override
    public Map<String, Object> getGradesByStudentId(int pageNum, int pageSize, int studentId) {
        Map<String, Object> data = new HashMap<>();
        int count = gradeMapper.getCountByStudentId(studentId);
        if (count == 0) {
            data.put("pageNum", 0);
            data.put("pageSize", 0);
            data.put("totalPageNum", 1);
            data.put("totalPageSize", 0);
            data.put("grades", new ArrayList<>());
            return data;
        }
        int totalPageNum = count % pageSize == 0 ? count / pageSize : count / pageSize + 1;
        if (pageNum > totalPageNum) {
            data.put("pageNum", 0);
            data.put("pageSize", 0);
            data.put("totalPageNum", totalPageNum);
            data.put("totalPageSize", 0);
            data.put("grades", new ArrayList<>());
            return data;
        }
        PageHelper.startPage(pageNum, pageSize);
        List<Grade> grades = gradeMapper.getGradesByStudentId(studentId);
        data.put("pageNum", pageNum);
        data.put("pageSize", pageSize);
        data.put("totalPageNum", totalPageNum);
        data.put("totalPageSize", count);
        data.put("grades", grades);
        return data;
    }

    @Override
    public List<Grade> getGradesByContestId(int contestId) {
        return gradeMapper.getGradesByContestId(contestId);
    }
}