基于springboot和mysql的模拟驾校考试系统源码

开发工具：idea或eclipse
数据库：mysql 数据库连接工具：navcat 

# 基于springboot和MySQL的模拟驾校考试系统 

## 项目主要功能介绍：

项目采用springboot+mybatis+MySQL+thymeleaf+layui+html来完成。
目前的主要功能：
前台：随机练习，顺序练习，专项练习，限时答题，模拟考试
后台：题库管理，考试管理（设置考试的时间长短）

http://localhost:8081/page/frontIndex

用户自行注册

 

package com.driving.code.controller;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.driving.code.entity.*;
import com.driving.code.service.QuestionService;
import com.driving.code.service.QuestionlogService;
import com.driving.code.utils.UploadUtils;
import org.springframework.web.bind.annotation.*;

import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * <p>
 * 驾校一点通，题库信息表 前端控制器
 * </p>
 *
 * @author 喜欢编程
 * @since 2023-03-14
 */
@RestController
@RequestMapping("question")
public class QuestionController {
    @Resource
    private QuestionService questionService;
    @Resource
    private QuestionlogService questionlogService;
    /**
     * 顺序练习，获取下一题
     * @param current
     * @return
     */
    @RequestMapping("getNextQuestionBySequence/{classify}/{current}/{flag}")
    public MyPage getNextQuestionBySequence(@PathVariable(value = "current") Integer current,@PathVariable(value = "classify") Integer classify,@PathVariable(value = "flag") String flag){
        IPage<Question> page = new Page(current,1);
        IPage<Question> questionIPage = null;
        if ("sequence".equals(flag)){
            questionIPage = questionService.page(page, new QueryWrapper<Question>().lambda().eq(Question::getQuestionClassify,classify));
        }
        if("mistakable".equals(flag)) {
            questionIPage = questionService.page(page, new QueryWrapper<Question>().lambda().eq(Question::getQuestionClassify,classify).ge(Question::getQuestionError,10));
        }
        if("uniterming".equals(flag)) {
            questionIPage = questionService.page(page, new QueryWrapper<Question>().lambda().eq(Question::getQuestionClassify,classify).eq(Question::getQuestionType,1));
        }
        if("multipleChoice".equals(flag)) {
            questionIPage = questionService.page(page, new QueryWrapper<Question>().lambda().eq(Question::getQuestionClassify,classify).eq(Question::getQuestionType,3));
        }
        if("trueOrFalse".equals(flag)) {
            questionIPage = questionService.page(page, new QueryWrapper<Question>().lambda().eq(Question::getQuestionClassify,classify).eq(Question::getQuestionType,2));
        }
        if (questionIPage == null){
            return null;
        }
        MyPage<Question> myPage = new MyPage<>(questionIPage.getTotal(), questionIPage.getCurrent(), questionIPage.getRecords());
        return myPage;
    }

    /**
     * 通过ID查询指定的问题
     * @return
     */
    @RequestMapping("getNextQuestionById/{index}")
    public Question getNextQuestionById(@PathVariable(value = "index") Integer index,HttpSession session){
        List<Integer> ids_random = (ArrayList<Integer>) session.getAttribute("ids_random");
        Integer id = ids_random.get(index);
        Question question = questionService.getById(id);
        return question;
    }

    /**
     * 获取全部的问题ID
     * @param classify
     * @return
     */
    @RequestMapping("getAllQuestionIdsBySequence/{classify}/{flag}")
    public List<Integer> getAllQuestionIdsBySequence(@PathVariable(value = "classify") Integer classify,@PathVariable(value = "flag") String flag){
        List<Question> list = null;
        if ("sequence".equals(flag)){
            list = questionService.list(new QueryWrapper<Question>().lambda().eq(Question::getQuestionClassify,classify));
        }

        if ("mistakable".equals(flag)){
            list = questionService.list(new QueryWrapper<Question>().lambda().eq(Question::getQuestionClassify,classify).ge(Question::getQuestionError,10));
        }

        if ("uniterming".equals(flag)){
            list = questionService.list(new QueryWrapper<Question>().lambda().eq(Question::getQuestionClassify,classify).eq(Question::getQuestionType,1));
        }

        if ("multipleChoice".equals(flag)){
            list = questionService.list(new QueryWrapper<Question>().lambda().eq(Question::getQuestionClassify,classify).eq(Question::getQuestionType,3));
        }

        if ("trueOrFalse".equals(flag)){
            list = questionService.list(new QueryWrapper<Question>().lambda().eq(Question::getQuestionClassify,classify).eq(Question::getQuestionType,2));
        }

        ArrayList<Integer> arrayList = new ArrayList<>();
        for (Question question : list) {
            arrayList.add(question.getQuestionId());
        }
        return arrayList;
    }

    /**
     * 获取全部的ID，并打乱，模拟随机查询。
     * @param classify
     * @return
     */
    @RequestMapping("getAllQuestionIdsByRandom/{classify}")
    public List<Integer> getAllQuestionIdsByRandom(@PathVariable(value = "classify") Integer classify, HttpSession session){
        List<Integer> ids = this.getAllQuestionIdsBySequence(classify,"sequence");
        Collections.shuffle(ids);
        session.setAttribute("ids_random",ids);
        return ids;
    }

    /**
     * 获得全部的问题
     * @param current
     * @param size
     * @param search
     * @return
     */
    @RequestMapping("getAllQuestion")
    public ParseData getAllQuestion(@RequestParam(value = "page",required = false,defaultValue = "1")Integer current,
                                    @RequestParam(value = "limit",required = false,defaultValue = "12")Integer size,
                                    @RequestParam(value = "search",required = false) String search,
                                    @RequestParam(value = "classify",required = false) Integer classify){
        IPage<Question> page = new Page(current,size);
        LambdaQueryWrapper<Question> queryWrapper = new QueryWrapper<Question>().lambda();
        if (search != null && search != ""){
            queryWrapper.like(Question::getQuestionTopic, search);
        }
        if (classify !=  null){
            queryWrapper.eq(Question::getQuestionClassify,classify);
        }
        IPage<Question> questionIPage = questionService.page(page, queryWrapper);
        ParseData<Question> parseData = new ParseData<>();
        parseData.setData(questionIPage.getRecords());
        parseData.setCode(0);
        parseData.setCount(questionIPage.getTotal());
        parseData.setMsg("请求成功");
        return parseData;
    }


    /**
     * 添加问题
     * @param question
     * @return
     */
    @RequestMapping("addQuestion")
    public String addQuestion(Question question){
        Answer answer = question.getAnswer();
        StringBuffer questionAnswer = new StringBuffer();
        if (answer.getQuestionAnswerA() != null && answer.getQuestionAnswerA() != ""){
            questionAnswer.append(answer.getQuestionAnswerA());
        }
        if (answer.getQuestionAnswerB() != null && answer.getQuestionAnswerB() != ""){
            questionAnswer.append(answer.getQuestionAnswerB());
        }
        if (answer.getQuestionAnswerC() != null && answer.getQuestionAnswerC() != ""){
            questionAnswer.append(answer.getQuestionAnswerC());
        }
        if (answer.getQuestionAnswerD() != null && answer.getQuestionAnswerD() != ""){
            questionAnswer.append(answer.getQuestionAnswerD());
        }
        if (answer.getQuestionAnswerE() != null && answer.getQuestionAnswerE() != ""){
            questionAnswer.append(answer.getQuestionAnswerE());
        }
        if (answer.getQuestionAnswerF() != null && answer.getQuestionAnswerF() != ""){
            questionAnswer.append(answer.getQuestionAnswerF());
        }
        if (answer.getQuestionAnswerG() != null && answer.getQuestionAnswerG() != ""){
            questionAnswer.append(answer.getQuestionAnswerG());
        }
        question.setQuestionAnswer(questionAnswer.toString());
        boolean save = questionService.save(question);
        if (save){
            return "1";
        }
        return "0";
    }

    /**
     * 上传图片
     * @param file
     * @return
     */
    @RequestMapping("uploadImage")
    public ParseData uploadImage(MultipartFile file,HttpServletRequest request){
        ParseData parseData = new ParseData();
        try{
            String location = UploadUtils.upload(file,request);
            parseData.setMsg(location);
            return parseData;
        }catch (Exception e){
            e.printStackTrace();
        }

        return parseData;
    }

    /**
     * 设置考试的试题
     * @param questionId
     * @param questionTest
     * @return
     */
    @RequestMapping("setQuestionTest")
    public String setQuestionTest(Integer questionId,Boolean questionTest){
        Question question = questionService.getById(questionId);
        question.setQuestionTest(questionTest);
        boolean b = questionService.updateById(question);
        if (b){
            return "1";
        }
        return "0";
    }


    /**
     * 获得考试的试题
     * @param current
     * @param classify
     * @return
     */
    @RequestMapping("getTestQuestion/{classify}/{current}")
    public MyPage getTestQuestion(@PathVariable(value = "current") Integer current,@PathVariable(value = "classify") Integer classify){
        IPage<Question> page = new Page<>(current, 1);
        IPage<Question> questionIPage = questionService.page(page, new QueryWrapper<Question>().lambda().eq(Question::getQuestionClassify, classify).eq(Question::getQuestionTest, true));
        MyPage<Question> myPage = new MyPage<>(questionIPage.getTotal(), questionIPage.getCurrent(), questionIPage.getRecords());
        return myPage;
    }

    /**
     * 获得考试问题的全部ID
     * @param classify
     * @return
     */
    @RequestMapping("getTestQuestionIds/{classify}")
    public List<Integer> getTestQuestionIds(@PathVariable(value = "classify") Integer classify){
        List<Question> list = questionService.list(new QueryWrapper<Question>().lambda().eq(Question::getQuestionClassify, classify).eq(Question::getQuestionTest,true));
        ArrayList<Integer> arrayList = new ArrayList<>();
        for (Question question : list) {
            arrayList.add(question.getQuestionId());
        }
        return arrayList;
    }

    /**
     * 删除问题
     * @param questionId
     * @return
     */
    @RequestMapping("deleteQuestion")
    public String deleteQuestion(Integer questionId){
        boolean delete = questionService.removeById(questionId);
        if (delete){
            return "1";
        }
        return "0";
    }


    /**
     * 如果用户回答错误，当前问题的错误数量加一。
     * @param questionId
     */
    @RequestMapping("questionError")
    public String questionError(Integer questionId,HttpSession session){
        Question question = questionService.getById(questionId);
        question.setQuestionError(question.getQuestionError()+1);
        boolean b = questionService.updateById(question);

        TUser user = (TUser) session.getAttribute("user");

        Questionlog questionlog = new Questionlog();
        questionlog.setQuestionId(questionId);
        questionlog.setQuestionTopic(question.getQuestionTopic());
        if("1".equals(question.getQuestionClassify())){
            questionlog.setQuestionClassify("科目一");
        }
        if("4".equals(question.getQuestionClassify())){
            questionlog.setQuestionClassify("科目四");
        }
        questionlog.setUserId(user.getUserId());
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
        questionlog.setCreatetime(df.format(new Date()));
        try{
            questionlogService.save(questionlog);
        }catch (Exception e){
            e.printStackTrace();
        }


        if(b){
            return "1";
        }
        return "0";
    }


    /**
     * 设置科目一的考试  限时时间
     * @param request
     * @param time_limit
     * @return
     */
    @RequestMapping("subjectOneTestTime")
    @ResponseBody
    public String subjectOneTestTime(HttpServletRequest request, Integer time_limit){
        ServletContext servletContext = request.getServletContext();
        servletContext.setAttribute("time_limit_one",time_limit);
        return "1";
    }

    /**
     * 设置科目四的考试  限时时间
     * @param request
     * @param time_limit
     * @return
     */
    @RequestMapping("subjectFourTestTime")
    @ResponseBody
    public String subjectFourTestTime(HttpServletRequest request,Integer time_limit){
        ServletContext servletContext = request.getServletContext();
        servletContext.setAttribute("time_limit_four",time_limit);
        return "1";
    }
}

错题集管理： 

 

 

 

package com.driving.code.controller;


import com.driving.code.entity.TUser;
import com.driving.code.service.TUserService;
import com.driving.code.utils.MyUsernamePasswordToken;
import com.driving.code.utils.RandomStringUtils;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.crypto.hash.Md5Hash;
import org.apache.shiro.subject.Subject;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpSession;

/**
 * <p>
 *  前端控制器
 * </p>
 *
 * @author 喜欢编程
 * @since 2023-03-14
 */
@RestController
@RequestMapping("user")
public class TUserController {
    @Resource
    private TUserService tUserService;

    /**
     * 注册方法
     * @param tUser
     * @return
     */
    @RequestMapping("register")
    public String register(TUser tUser){
        String string = RandomStringUtils.getString(5);
        tUser.setUserSalt(string);
        Md5Hash md5Hash = new Md5Hash(tUser.getUserPassword(),string,1024);
        String password = md5Hash.toHex();
        tUser.setUserPassword(password);


        int num = (int) (Math.random()*21);
        tUser.setUserImage("/image/front/touxiang/"+num+".jpg");
        boolean save = tUserService.save(tUser);
        if (save){
            return "1";
        }
        return "0";
    }

    /**
     * 登录方法
     * @param userAccount
     * @param password
     * @return
     */
    @RequestMapping("login")
    public String login(String userAccount,String password){
        MyUsernamePasswordToken token = new MyUsernamePasswordToken(userAccount,password,"UserRealm");
        Subject subject = SecurityUtils.getSubject();
        subject.login(token);
        return "0";
    }

    /**
     * 退出方法
     * @return
     */
    @RequestMapping("logout")
    public String logout(){
        Subject subject = SecurityUtils.getSubject();
        subject.logout();
        return "1";
    }

    /**
     * 修改照片
     * @return
     */
    @RequestMapping("updateImage")
    public void updateImage(@RequestBody TUser user_post, HttpSession session){
        TUser user = (TUser) session.getAttribute("user");
        user.setUserImage(user_post.getUserImage());
        tUserService.updateById(user);
        session.setAttribute("user",user);
    }

    /**
     * 获取我的个人信息
     * @return
     */
    @RequestMapping("getMyInformation")
    @ResponseBody
    public TUser getMyInformation(HttpSession session){
        TUser user = (TUser) session.getAttribute("user");
        TUser tUser = tUserService.getById(user.getUserId());
        return tUser;
    }
}

 

package com.driving.code.controller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.driving.code.entity.Liuyan;
import com.driving.code.entity.TUser;
import com.driving.code.service.LiuyanService;
import com.driving.code.service.TUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;
import javax.servlet.http.HttpSession;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

/**
 * @author
 * @date 2021-12-29 10:28
 */
@Controller
@RequestMapping("liuyan")
public class LiuyanController {

    @Resource
    private LiuyanService liuyanService;
    @Resource
    private TUserService tUserService;

    /**
     * 跳转到网站
     * @return
     */
    @RequestMapping("note")
    public String note(Model model){
       try{
           QueryWrapper<Liuyan> queryWrapper = new QueryWrapper<>();
           queryWrapper.eq("fid",0).eq("level",1);
           queryWrapper.orderByDesc("createtime");
           List<Liuyan> list = liuyanService.list(queryWrapper);
           if(list.size()>0){
               for (Liuyan liuyan:list) {
                   QueryWrapper<Liuyan> queryWrapper1 = new QueryWrapper<>();
                   queryWrapper1.eq("fid",liuyan.getId()).eq("level",2);
                   queryWrapper1.orderByDesc("createtime");
                   List<Liuyan> list1 = liuyanService.list(queryWrapper1);
                   liuyan.setRlist(list1);
               }
           }
           model.addAttribute("list",list);
       }catch (Exception e){
         e.printStackTrace();
       }


        return "front/note";
    }



    @RequestMapping("addLiuYan")
    public String addLiuYan(HttpSession session,String content, Integer liuyanId, Integer uid){
        try{
        TUser user = (TUser) session.getAttribute("user");
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
        Liuyan liuyan = new Liuyan();
        liuyan.setCreatetime(df.format(new Date()));
        liuyan.setUid(user.getUserId());
        liuyan.setUsername(user.getUserName());
        liuyan.setContent(content);
            liuyan.setRemark1(user.getUserImage());
        if(liuyanId!=null && uid!=null){
           Liuyan liuyan1 =  liuyanService.getById(liuyanId);
           if(liuyan1.getLevel()==1){
               liuyan.setFid(liuyanId);
           }
            if(liuyan1.getLevel()==2){
                liuyan.setFid(liuyan1.getFid());
            }
           TUser u =  tUserService.getById(uid);

            liuyan.setLevel(2);
            liuyan.setIntro(u.getUserName());

        }else{
            liuyan.setFid(0);
            liuyan.setLevel(1);
        }

        liuyanService.save(liuyan);

        }catch (Exception e){
            e.printStackTrace();
        }

        return "redirect:/liuyan/note";
    }


}