Java Online Exam在线考试系统的实现

一、项目简述

本系统主要实现的功能有： 学生以及老师的注册登录，在线考试，错题查询，学生管理，问题管理，错题管理，错题查询，分数查询，试卷管 理，人工组卷。自动组卷，教师，班级，统计等等管理功能。

二、项目运行

环境配置： Jdk1.8 + Tomcat8.5 + mysql + Eclispe (IntelliJ IDEA,Eclispe,MyEclispe,Sts 都支持)

项目技术： VUE+Springboot+ SpringMVC + MyBatis + ThymeLeaf + JavaScript + JQuery + Ajax + maven等等

Java Online Exam在线考试系统的实现_第1张图片

Java Online Exam在线考试系统的实现_第2张图片

Java Online Exam在线考试系统的实现_第3张图片

Java Online Exam在线考试系统的实现_第4张图片

Java Online Exam在线考试系统的实现_第5张图片

课程信息控制器:

 
/**
 * yy
 */
@RestController
@RequestMapping(value = "/v1/subjects")
public class SubjectController {
 
    private static Logger logger = LoggerFactory.getLogger(SubjectController.class);
 
    @Autowired
    SubjectService subjectService;
 
    @ApiOperation(value = "获取科目列表", notes = "")
    @RequestMapping(value = "", method = RequestMethod.GET)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "')")
    public PageInfo getSubjectList(@RequestParam(required = false) Integer pageIndex,
                                        @RequestParam(required = false) Integer pageSize,
                                        @RequestParam(required = false) Integer limit,
                                        @RequestParam(required = false) Integer offset) {
        if(pageIndex != null && pageSize != null) {
            PageHelper.startPage(pageIndex, pageSize);
        }
        List subjects = subjectService.getSubjectList();
        PageInfo pageInfo = new PageInfo(subjects);
        return pageInfo;
    }
 
    @ApiOperation(value = "根据名字获取科目信息", notes = "根据科目名称获取科目详细信息")
    @ApiImplicitParam(name = "name", value = "科目名称", required = true, dataType = "String", paramType = "path")
    @RequestMapping(value = "/{name}/name", method = RequestMethod.GET)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "')")
    public List getSubjectByName(@PathVariable String name) {
        return subjectService.getSubjectFuzzy(name);
    }
 
 
    @ApiOperation(value = "获取课程信息", notes = "根据课程id获取课程详细信息")
    @ApiImplicitParam(name = "idOrName", value = "课程ID或名称", required = true, dataType = "String", paramType = "path")
    @RequestMapping(value = "/search/{idOrName}", method = RequestMethod.GET)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "')")
    public List getSubjectForSearch(@PathVariable String idOrName) {
        List subjects = new ArrayList();
        Subject subject = subjectService.getSubjectByName(idOrName);
        if (subject == null) {
            try {
                subject = subjectService.getSubjectById(idOrName);
            } catch (Exception e) {
 
            }
        }
        if (subject != null) {
            subjects.add(subject);
        }
        return subjects;
    }
 
    @ApiOperation(value = "创建课程", notes = "创建课程")
    @ApiImplicitParam(name = "subject", value = "课程实体Subject", required = true, dataType = "Subject")
    @RequestMapping(value = "", method = RequestMethod.POST)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "')")
    public ResponseEntity postSubject(@RequestBody Subject subject) {
        if(subjectService.getSubjectByName(subject.getName()) != null) {
            return new ResponseEntity(new Dto("课程已存在！"), HttpStatus.INTERNAL_SERVER_ERROR);
        }
        subjectService.saveSubject(subject);
        return new ResponseEntity(HttpStatus.CREATED);
    }
 
    @ApiOperation(value = "获取课程信息", notes = "根据课程id获取课程详细信息")
    @ApiImplicitParam(name = "id", value = "课程ID", required = true, dataType = "String", paramType = "path")
    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "')")
    public Subject getSubject(@PathVariable String id) {
        return subjectService.getSubjectById(id);
    }
 
    @ApiOperation(value = "更新课程信息", notes = "根据课程id更新用户信息")
    @ApiImplicitParam(name = "subject", value = "课程实体", required = true, dataType = "Subject")
    @RequestMapping(value = "", method = RequestMethod.PUT)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "')")
    public ResponseEntity putSubject(@RequestBody Subject subject) {
        subjectService.updateSubject(subject);
        return new ResponseEntity(HttpStatus.OK);
    }
 
    @ApiOperation(value = "删除课程", notes = "根据课程id删除课程")
    @ApiImplicitParam(name = "id", value = "课程ID", required = true, dataType = "Long", paramType = "path")
    @RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "')")
    public ResponseEntity deleteSubject(@PathVariable String id) {
        try {
            subjectService.deleteSubject(id);
        }catch (RuntimeException e) {
            return new ResponseEntity(new Dto("该课程包含有考试，不能删除"), HttpStatus.INTERNAL_SERVER_ERROR);
        }
        return new ResponseEntity(HttpStatus.OK);
    }
}
  
  
 
题目信息控制器：
 
 
 
  
/**
 * yy
 */
 
@RestController
@RequestMapping(value = "/v1/questions")
public class QuestionController {
 
    private static Logger logger = LoggerFactory.getLogger(QuestionController.class);
 
    @Autowired
    QuestionService questionService;
 
    @Autowired
    PaperAnswerPaperService paperAnswerPaperService;
 
    @ApiOperation(value = "获取题目分页列表", notes = "")
    @RequestMapping(value = "", method = RequestMethod.GET)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "')")
    public PageInfo getQuestionListByPage(@RequestParam(required = false) Integer pageIndex,
                                                    @RequestParam(required = false) Integer pageSize,
                                                    @RequestParam(required = false) Integer limit,
                                                    @RequestParam(required = false) Integer offset) {
        if(pageIndex != null && pageSize != null) {
            PageHelper.startPage(pageIndex, pageSize);
        }
        List questions = questionService.getQuestionList();
        PageInfo pageInfo = new PageInfo(questions);
        return pageInfo;
    }
 
    @ApiOperation(value = "获取试卷题目分页列表", notes = "")
    @RequestMapping(value = "/papers/{paperId}", method = RequestMethod.GET)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "')")
    public PageInfo getQuestionListByPaper(@PathVariable String paperId,
                                                     @RequestParam(required = false) Integer pageIndex,
                                                     @RequestParam(required = false) Integer pageSize,
                                                     @RequestParam(required = false) Integer limit,
                                                     @RequestParam(required = false) Integer offset) {
        if(pageIndex != null && pageSize != null) {
            PageHelper.startPage(pageIndex, pageSize);
        }
        List questions = questionService.getQuestionListByPaper(paperId);
        PageInfo pageInfo = new PageInfo(questions);
        return pageInfo;
    }
 
    @ApiOperation(value = "获取试卷题目数量", notes = "")
    @RequestMapping(value = "/papers/{paperId}/count", method = RequestMethod.GET)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "') or hasAuthority('" + Role.ROLE_STUDENT + "')")
    public ResponseEntity getQuestionCountByPaper(@PathVariable String paperId) {
        Integer count = questionService.countByPaperId(paperId);
        return new ResponseEntity(count, HttpStatus.OK);
    }
 
    @ApiOperation(value = "创建题目", notes = "创建题目")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "question", value = "题目实体Question", required = true, dataType = "Question"),
            @ApiImplicitParam(name = "id", value = "试卷id", required = true, dataType = "String", paramType = "path")
    })
    @RequestMapping(value = "/{id}", method = RequestMethod.POST)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "')")
    public ResponseEntity postQuestion(@PathVariable("id") String id, @RequestBody Question question) {
        questionService.saveQuestion(id, question);
        return new ResponseEntity(HttpStatus.CREATED);
    }
 
    @ApiOperation(value = "获取题目信息", notes = "根据题目id获取题目详细信息")
    @ApiImplicitParam(name = "id", value = "题目ID", required = true, dataType = "String", paramType = "path")
    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "') or hasAuthority('" + Role.ROLE_STUDENT + "')")
    public Question getQuestion(@PathVariable String id) {
        return questionService.getQuestion(id);
    }
 
    @ApiOperation(value = "根据试卷id和题目编号获取题目信息", notes = "根据题目id获取题目详细信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "paperId", value = "试卷ID", required = true, dataType = "String", paramType = "path"),
            @ApiImplicitParam(name = "number", value = "题目编号", required = true, dataType = "String", paramType = "path")
    })
    @RequestMapping(value = "/papers/{paperId}/questions/{number}", method = RequestMethod.GET)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "') or hasAuthority('" + Role.ROLE_STUDENT + "')")
    public Question getQuestionByPaperIdAndQuestionId(@PathVariable String paperId,
                                                      @PathVariable Integer number,
                                                      @RequestParam(required = false) String answerPaperId) {
        PaperAnswerPaper paperAnswerPaper = null;
        //传入的是答卷Id
        if(answerPaperId != null) {
            // TODO: 2017-04-17
            paperAnswerPaper = paperAnswerPaperService.getByAnswerPaperId(answerPaperId);
            if(paperAnswerPaper != null) {
                return questionService.getQuestionByPaperIdAndQuestionNumber(paperAnswerPaper.getPaperId(), number);
            }else {
                logger.error("根据答卷id获取答卷失败");
            }
        }
        return questionService.getQuestionByPaperIdAndQuestionNumber(paperId, number);
    }
 
    @ApiOperation(value = "获取题目信息", notes = "根据题目name获取题目详细信息")
    @ApiImplicitParam(name = "name", value = "试卷name", required = true, dataType = "String", paramType = "path")
    @RequestMapping(value = "/name/{name}", method = RequestMethod.GET)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "') or hasAuthority('" + Role.ROLE_STUDENT + "')")
    public List getQuestionByName(@PathVariable String name) {
        //模糊查询
        return questionService.getQuestionFuzzy(name);
    }
 
    @ApiOperation(value = "获取题目信息", notes = "根据试卷id获取所有题目")
    @ApiImplicitParam(name = "paperId", value = "试卷ID", required = true, dataType = "String", paramType = "path")
    @RequestMapping(value = "/papers/{paperId}/questions", method = RequestMethod.GET)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "') or hasAuthority('" + Role.ROLE_STUDENT + "')")
    public List getQuestionByPaperId(@PathVariable String paperId) {
        return questionService.getQuestionByPaperId(paperId);
    }
 
    @ApiOperation(value = "获取题目信息", notes = "根据试卷id获取所有题目,但不返回答案")
    @ApiImplicitParam(name = "paperId", value = "试卷ID", required = true, dataType = "String", paramType = "path")
    @RequestMapping(value = "/papers/{paperId}/ignore", method = RequestMethod.GET)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "') or hasAuthority('" + Role.ROLE_STUDENT + "')")
    public List getQuestionByPaperIdIgnoreAnswer(@PathVariable String paperId) {
        return questionService.getQuestionByPaperIdIgnoreAnswer(paperId);
    }
 
    @ApiOperation(value = "更新题目信息", notes = "根据题目id更新题目信息")
    @ApiImplicitParam(name = "question", value = "题目实体", required = true, dataType = "Question")
    @RequestMapping(value = "", method = RequestMethod.PUT)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "')")
    public ResponseEntity putQuestion(@RequestBody Question question) {
        questionService.updateQuestion(question);
        return new ResponseEntity(HttpStatus.OK);
    }
 
    @ApiOperation(value = "删除题目", notes = "根据题目id删除试卷")
    @ApiImplicitParam(name = "id", value = "题目ID", required = true, dataType = "String", paramType = "path")
    @RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "')")
    public ResponseEntity deleteQuestion(@PathVariable String id) {
        questionService.deleteQuestion(id);
        return new ResponseEntity(HttpStatus.OK);
    }
} 
  
 
考试控制层，负责试卷提交等：
 
 
 
  
/**
 * 考试控制层，负责试卷提交等
 */
@RestController
@RequestMapping("/v1/exam")
public class ExamController {
 
    @Autowired
    ExamService examService;
 
    @Autowired
    AnswerPaperService answerPaperService;
 
    @Autowired
    AnswerQuestionService answerQuestionService;
 
    @Autowired
    AnswerPaperQuestionService answerPaperQuestionService;
 
    @Autowired
    QuestionService questionService;
 
    @Autowired
    PaperService paperService;
 
    @Autowired
    WrongQuestionService wrongQuestionService;
 
    @Autowired
    PaperAnswerPaperService paperAnswerPaperService;
 
    @ApiOperation(value = "根据试卷id和题目编号获取题目信息", notes = "根据题目id获取题目详细信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "paperId", value = "试卷ID", required = true, dataType = "String", paramType = "path"),
            @ApiImplicitParam(name = "number", value = "题目编号", required = true, dataType = "String", paramType = "path")
    })
    @RequestMapping(value = "/questions/{number}", method = RequestMethod.GET)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "') or hasAuthority('" + Role.ROLE_STUDENT + "')")
    public Question getQuestionByPaperIdAndQuestionId(@RequestParam String paperId,
                                                      @RequestParam String username,
                                                      @RequestParam(required = false) String answerPaperId,
                                                      @PathVariable Integer number) {
        Question question = null;
        AnswerQuestion answerQuestion = null;
        if(answerPaperId == null) {
            Paper paper = paperService.getPaperById(paperId);
            if(paper != null) {
                AnswerPaper answerPaper = answerPaperService.findByAnswerUserAndPaperName(username, paper.getName());
                if(answerPaper != null) {
                    answerQuestion = answerQuestionService.getAnswerQuestionByPaperIdAndQuestionNumber(answerPaper.getId(), number);
                }
            }
        }else {
            answerQuestion = answerQuestionService.getAnswerQuestionByPaperIdAndQuestionNumber(answerPaperId, number);
        }
 
        if(answerQuestion == null) {
            question = questionService.getQuestionByPaperIdAndQuestionNumber(paperId, number);
            if(question != null) {
                //答案不返回
                question.setAnswer("");
            }
        } else {
            question = new Question();
            question.setId(answerQuestion.getId());
            question.setNumber(answerQuestion.getNumber());
            question.setTitle(answerQuestion.getTitle());
            question.setScore(answerQuestion.getScore());
            question.setType(answerQuestion.getType());
            question.setOptionA(answerQuestion.getOptionA());
            question.setOptionB(answerQuestion.getOptionB());
            question.setOptionC(answerQuestion.getOptionC());
            question.setOptionD(answerQuestion.getOptionD());
            question.setAnswer(answerQuestion.getAnswer());
        }
        return question;
    }
 
    @RequestMapping(value = "/submit/{type}/{username}", method = RequestMethod.POST)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "') or hasAuthority('" + Role.ROLE_STUDENT + "')")
    public ResponseEntity submit(@RequestBody Paper paper, @PathVariable String type,
                                    @PathVariable String username,
                                    @RequestParam(required = false) String answerPaperId) {
        /**
         * 更改试卷状态，finished:true
         */
        if(type.equals("official")) {
            /**
             * 正式考试
             */
            AnswerPaper answerPaper = new AnswerPaper();
            if(answerPaperId != null) {
                answerPaper.setId(answerPaperId);
            }else {
                return new ResponseEntity(HttpStatus.INTERNAL_SERVER_ERROR);
            }
            answerPaper.setAnswerTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            answerPaper.setPaperName(paper.getName());
            answerPaper.setAnswerUser(username);
            answerPaper.setChecked("false");
            answerPaper.setFinished("true");
            answerPaper.setType("official");
            examService.updateAnswerPaper(answerPaper);
        } else if(type.equals("simulate")) {
            /**
             * 模拟考试
             */
            AnswerPaper answerPaper = new AnswerPaper();
            if(answerPaperId != null) {
                answerPaper.setId(answerPaperId);
            }else {
                return new ResponseEntity(HttpStatus.INTERNAL_SERVER_ERROR);
            }
            answerPaper.setAnswerTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            answerPaper.setPaperName(paper.getName());
            answerPaper.setAnswerUser(username);
            answerPaper.setChecked("false");
            answerPaper.setFinished("true");
            answerPaper.setType("simulate");
            examService.updateAnswerPaper(answerPaper);
        }else if(type.equals("practice")) {
            /**
             * 1.接收提交的试卷
             * 2.计算成绩
             * 3.记录考试记录
             * 4.返回计算结果
             */
            int score = 0;
 
            //正确题目数
            double right = 0.0;
 
            //错误题目数
            double wrong = 0.0;
 
            double correctRate = 0.0;
 
            List questions = questionService.getQuestionByPaperId(paper.getId());
 
            AnswerPaper answerPaper = answerPaperService.findByAnswerUserAndPaperName(username, paper.getName());
 
            List answerQuestions = answerQuestionService.findByAnswerPaperId(answerPaper.getId());
 
            /*保存题目信息，返回给前端*/
            List results = new ArrayList();
 
            DtoRightAndWrong dtoRightAndWrong = null;
 
            //遍历提交的试卷的题目
            for(AnswerQuestion answerQuestion : answerQuestions) {
 
                //遍历包含正确答案的题目
                for(Question question : questions) {
                    /**
                     * 1.题目序号相同
                     * 2.结果与答案相同
                     */
                    if(answerQuestion.getNumber().equals(question.getNumber())) {
                        if(answerQuestion.getAnswer().equals(question.getAnswer())) {
                            /*累计得分*/
                            score += Integer.parseInt(question.getScore());
                            right ++;
                        }else {
                            wrong ++;
                            //记录错题
                            dtoRightAndWrong = new DtoRightAndWrong();
                            dtoRightAndWrong.setQuestion(question);
                            dtoRightAndWrong.setAnswerQuestion(answerQuestion);
                            results.add(dtoRightAndWrong);
 
                            //保存错题
                            WrongQuestion wrongQuestion = new WrongQuestion();
                            try{
                                BeanUtils.copyProperties(wrongQuestion, answerQuestion);
                                wrongQuestion.setUsername(username);
                                wrongQuestion.setRightAnswer(question.getAnswer());
                                wrongQuestion.setAnalysis(question.getAnalysis());
                                if(wrongQuestionService.getWrongQuestion(wrongQuestion.getId()) == null) {
                                    wrongQuestionService.saveQuestion(wrongQuestion);
                                }
                            }catch (Exception e) {
                                System.out.println(wrongQuestion.toString());
                            }
 
                        }
                    }
                }
            }
            //计算正确率
            correctRate = (right/(right + wrong)) * 100;
 
            DtoResult result = new DtoResult();
            result.setScore(score);
            result.setRight(right);
            result.setWrong(wrong);
            result.setCorrectRate(correctRate);
            result.setResults(results);
 
            Paper paper1 = paperService.getPaperById(paper.getId());
            //更新参与人数
            paper1.setPeoples(String.valueOf(Integer.parseInt(paper1.getPeoples()) + 1));
            paperService.updatePaper(paper1);
 
            return new ResponseEntity(result, HttpStatus.OK);
        }
        Paper paper1 = paperService.getPaperById(paper.getId());
        //更新参与人数
        paper1.setPeoples(String.valueOf(Integer.parseInt(paper1.getPeoples() + 1)));
        paperService.updatePaper(paper1);
        return new ResponseEntity(HttpStatus.OK);
    }
 
    /**
     * 提交题目
     * @param username
     * @param dtoAnswerPaper
     * @return
     */
    @RequestMapping(value = "/submit/one/{username}", method = RequestMethod.POST)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "') or hasAuthority('" + Role.ROLE_STUDENT + "')")
    public ResponseEntity submitOne(@PathVariable String username, @RequestBody DtoAnswerPaper dtoAnswerPaper) {
        Paper paper = dtoAnswerPaper.getPaper();
        Question question = dtoAnswerPaper.getQuestion();
        //判断数据库是否保存了这次答卷
        AnswerPaper answerPaper = answerPaperService.getAnswerPaperByNameAndUser(paper.getName(), username);
        AnswerQuestion answerQuestion = null;
        AnswerPaperQuestion answerPaperQuestion = null;
        List answerQuestions = null;
        //重新生成id
        String answerPaperId = IdGen.uuid();
        String answerQuestionId = IdGen.uuid();
        //答卷为空，则执行保存
        if(answerPaper == null) {
            answerPaper = new AnswerPaper();
            answerPaper.setId(answerPaperId);
            answerPaper.setAnswerTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            answerPaper.setPaperName(paper.getName());
            answerPaper.setType(paper.getType());
            answerPaper.setAnswerUser(username);
            answerPaper.setChecked("false");
            answerPaper.setFinished("false");
 
            //保存答卷
            answerPaperService.saveAnswerPaper(answerPaper);
 
            // TODO: 2017-04-17 保存试卷答卷
            PaperAnswerPaper paperAnswerPaper = new PaperAnswerPaper();
            paperAnswerPaper.setPaperId(paper.getId());
            paperAnswerPaper.setAnswerPaperId(answerPaperId);
            paperAnswerPaperService.save(paperAnswerPaper);
 
            //新记录
            answerQuestion = new AnswerQuestion();
            //初始化信息
            answerQuestion.setId(answerQuestionId);
            answerQuestion.setTitle(question.getTitle());
            answerQuestion.setType(question.getType());
            answerQuestion.setNumber(question.getNumber());
            answerQuestion.setOptionA(question.getOptionA());
            answerQuestion.setOptionB(question.getOptionB());
            answerQuestion.setOptionC(question.getOptionC());
            answerQuestion.setOptionD(question.getOptionD());
            answerQuestion.setContent(question.getContent());
            answerQuestion.setScore(question.getScore());
            answerQuestion.setAnalysis(question.getAnalysis());
            answerQuestion.setAnswer(question.getAnswer());
 
 
            answerPaperQuestion = new AnswerPaperQuestion();
            answerPaperQuestion.setAnswerPaperId(answerPaper.getId());
            answerPaperQuestion.setAnswerQuestionId(answerQuestionId);
 
            //保存
            answerQuestionService.saveAnswerQuestion(answerQuestion);
            answerPaperQuestionService.saveAnswerPaperQuestion(answerPaperQuestion);
 
            return new ResponseEntity(answerPaper, HttpStatus.OK);
        } else {
            answerQuestions = answerQuestionService.findByAnswerPaperId(answerPaper.getId());
            if(answerQuestions != null && answerQuestions.size() > 0) {
                int count = 0;
                AnswerQuestion existAnswerQuestion = null;
                for(AnswerQuestion question1 : answerQuestions) {
                    if (question1.getNumber().equals(question.getNumber())) {
                        count++;
                        existAnswerQuestion = question1;//保存当前存在的记录
                    }
                }
                //记录不存在
                if(count == 0) {
                    //新记录
                    answerQuestion = new AnswerQuestion();
                    answerPaperQuestion = new AnswerPaperQuestion();
 
 
                    answerQuestion = new AnswerQuestion();
                    //初始化信息
                    answerQuestion.setId(answerQuestionId);
                    answerQuestion.setTitle(question.getTitle());
                    answerQuestion.setType(question.getType());
                    answerQuestion.setNumber(question.getNumber());
                    answerQuestion.setOptionA(question.getOptionA());
                    answerQuestion.setOptionB(question.getOptionB());
                    answerQuestion.setOptionC(question.getOptionC());
                    answerQuestion.setOptionD(question.getOptionD());
                    answerQuestion.setContent(question.getContent());
                    answerQuestion.setScore(question.getScore());
                    answerQuestion.setAnalysis(question.getAnalysis());
                    answerQuestion.setAnswer(question.getAnswer());
 
 
                    answerPaperQuestion = new AnswerPaperQuestion();
                    answerPaperQuestion.setAnswerPaperId(answerPaper.getId());
                    answerPaperQuestion.setAnswerQuestionId(answerQuestionId);
 
                    //保存
                    answerQuestionService.saveAnswerQuestion(answerQuestion);
                    answerPaperQuestionService.saveAnswerPaperQuestion(answerPaperQuestion);
                } else {
                    //记录存在，则执行更新
                    // TODO: 2017/3/30
                    //更新当前存在的记录
                    existAnswerQuestion.setAnswer(question.getAnswer());
 
                    answerQuestionService.updateAnswerQuestion(existAnswerQuestion);
                }
            }
        }
        return new ResponseEntity(answerPaper, HttpStatus.OK);
    }
} 
  
 
答卷控制层，用于获取已经提交的答卷:
 
 
 
  
/**
 * 答卷控制层，用于获取已经提交的答卷
 */
@RestController
@RequestMapping("/v1/answer-papers")
public class AnswerPaperController {
 
    @Autowired
    AnswerPaperService answerPaperService;
 
    @Autowired
    AnswerQuestionService answerQuestionService;
 
    /**
     * 根据ID查找
     * @param id
     * @return
     */
    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "') or hasAuthority('" + Role.ROLE_STUDENT + "')")
    public AnswerPaper getAnswerPaper(@PathVariable String id) {
        return answerPaperService.getAnswerPaperById(id);
    }
 
    /**
     * 根据name查找
     * @param name
     * @return
     */
    @RequestMapping(value = "/name/{name}", method = RequestMethod.GET)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "')")
    public List getAnswerPaperByName(@PathVariable String name) {
        return answerPaperService.getAnswerPaperFuzzy(name);
    }
 
    /**
     * 根据答卷id和题目编号获取题目信息
     * @param paperId
     * @param number
     * @return
     */
    @RequestMapping(value = "/papers/{paperId}/questions/{number}", method = RequestMethod.GET)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "') or hasAuthority('" + Role.ROLE_STUDENT + "')")
    public AnswerQuestion getQuestionByPaperIdAndQuestionId(@PathVariable String paperId, @PathVariable Integer number) {
        AnswerQuestion answerQuestion = answerQuestionService.getAnswerQuestionByPaperIdAndQuestionNumber(paperId, number);
        return answerQuestion;
    }
 
    /**
     * 已分页方式获取数据
     * @param username
     * @param pageIndex
     * @param pageSize
     * @param limit
     * @param offset
     * @return
     */
    @RequestMapping(value = "/users/{username}", method = RequestMethod.GET)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "') or hasAuthority('" + Role.ROLE_STUDENT + "')")
    public PageInfo getListByUser(@PathVariable("username") String username,
                                               @RequestParam(required = false) Integer pageIndex,
                                               @RequestParam(required = false) Integer pageSize,
                                               @RequestParam(required = false) Integer limit,
                                               @RequestParam(required = false) Integer offset) {
        if(pageIndex != null && pageSize != null) {
            PageHelper.startPage(pageIndex, pageSize);
        }
        List answerPapers = answerPaperService.getAnswerPaperListByAnswerUser(username);
        PageInfo pageInfo = new PageInfo(answerPapers);
        return pageInfo;
    }
 
    @RequestMapping(value = "/users/{username}/type/{type}", method = RequestMethod.GET)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "') or hasAuthority('" + Role.ROLE_STUDENT + "')")
    public PageInfo getListByUserAndType(@PathVariable("username") String username,
                                                @PathVariable("type") String type,
                                                @RequestParam(required = false) Integer pageIndex,
                                                @RequestParam(required = false) Integer pageSize,
                                                @RequestParam(required = false) Integer limit,
                                                @RequestParam(required = false) Integer offset) {
        if(pageIndex != null && pageSize != null) {
            PageHelper.startPage(pageIndex, pageSize);
        }
        List answerPapers = answerPaperService.getAnswerPaperListByAnswerUserAndType(username, type);
        PageInfo pageInfo = new PageInfo(answerPapers);
        return pageInfo;
    }
 
    /**
     * 获取未批改或已批改的答卷数量，
     * @return
     */
    @RequestMapping("/check")
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "')")
    public DtoTask countUnCheckAnswerPaper() {
        DtoTask dtoTask = new DtoTask();
        Integer checked = answerPaperService.countCheck("true");
        Integer unChecked = answerPaperService.countCheck("false");
        dtoTask.setChecked(checked);
        dtoTask.setUnChecked(unChecked);
        return dtoTask;
    }
 
    /**
     * 以分页方式获取数据
     * @param pageIndex
     * @param pageSize
     * @param limit
     * @param offset
     * @return
     */
    @RequestMapping(value = "", method = RequestMethod.GET)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "')")
    public PageInfo getListByUser(@RequestParam(required = false) Integer pageIndex,
                                               @RequestParam(required = false) Integer pageSize,
                                               @RequestParam(required = false) Integer limit,
                                               @RequestParam(required = false) Integer offset) {
        if(pageIndex != null && pageSize != null) {
            PageHelper.startPage(pageIndex, pageSize);
        }
        List answerPapers = answerPaperService.getAnswerPaperList();
        PageInfo pageInfo = new PageInfo(answerPapers);
        return pageInfo;
    }
 
    /**
     * 更新
     * @param answerPaper
     * @return
     */
    @RequestMapping(value = "", method = RequestMethod.PUT)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "')")
    public ResponseEntity putPaper(@RequestBody AnswerPaper answerPaper) {
        answerPaperService.updatePaper(answerPaper);
        return new ResponseEntity(HttpStatus.OK);
    }
 
    /**
     * 计算考试成绩
     * @param id
     * @return
     */
    @RequestMapping(value = "/{id}/calculate", method = RequestMethod.PUT)
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "') or hasAuthority('" + Role.ROLE_STUDENT + "')")
    public ResponseEntity CalculationScore(@PathVariable String id) {
        /**
         * 计算成绩
         */
        List questions = answerQuestionService.findByAnswerPaperId(id);
        if(questions != null && questions.size() > 0) {
 
            int score = 0;
            try {
                for(AnswerQuestion question : questions) {
                    score += Integer.parseInt(question.getMarkScore());
                }
            } catch (Exception e) {
                // TODO: 2017/4/1
            }
 
            /**
             * 保存成绩
             */
 
            AnswerPaper answerPaper = new AnswerPaper();
            answerPaper.setId(id);
            answerPaper.setScore(Integer.toString(score));
            answerPaper.setChecked("true");
            answerPaperService.updatePaper(answerPaper);
        } else {
            // TODO: 2017/4/1
        }
        return new ResponseEntity(HttpStatus.OK);
    }
 
    @RequestMapping(value = "/analysis/paper")
    @PreAuthorize("hasAuthority('" + Role.ROLE_TEACHER + "') or hasAuthority('" + Role.ROLE_ADMIN + "')")
    public List analysisPaper() {
        return answerPaperService.analysisPaper();
    }
} 
  
 
以上就是Java Online Exam在线考试系统的实现的详细内容，更多关于Java 在线考试系统的资料请关注脚本之家其它相关文章！
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Java Online Exam在线考试系统的实现)

        

            

                
    
                    
  • 深度探索：SQL Server 技术学习之旅
                        小码快撩
数据库sqlserversql
                        
    引言在数字化时代，数据库管理系统作为企业信息系统的核心组件，承载着海量数据的存储、管理和分析重任。其中，MicrosoftSQLServer作为一款久经市场考验的企业级关系型数据库平台，凭借其强大的功能、卓越的性能以及与微软生态系统的深度集成，赢得了全球众多企业的青睐。本文旨在引导读者踏上深入学习SQLServer的旅程，全方位领略其核心技术要点，为构建高效、稳定且安全的数据库系统奠定坚实基础。一
    
                    
    • 
                    
  • 第十五届蓝桥杯软件赛C/C++大学A组个人省赛题解
                        2301_78234743
java
                        
    题解|#压缩字符串(一)#/***代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可***@4月末字节offer，51可以放松一下了从三月初开始零碎的投递，到三月底开始海投，三月的时候面试的机会其实很少，到4月初面试机会才逐渐多了起题解|#四则运算#importjava.util.*;//注意类名必须为Main,不要有任何package众远智慧离谱电话面2月底投的写完了笔试，
    
                    
    • 
                    
  • MYSQL学习笔记(五)：单行函数(字符串、数学、日期时间、条件判断、信息、加密、进制转换函数)讲解
                        羊小猪~~
MYSQLmysql学习笔记sql数据库考研后端
                        
    前言：学习和使用数据库可以说是程序员必须具备能力，这里将更新关于MYSQL的使用讲解，大概应该会更新30篇+，涵盖入门、进阶、高级(一些原理分析);这一篇是讲解单行函数，当然mysql函数很多哈，只有多用才能记得住；这些函数，如果不用，记得再牢都会忘记(我是这样的)，但是可以先看一下，动手打一下，会现用现查即可，而且现在AI这么发达不是么；虽然MYSQL命令很多，但是自己去多敲一点，到后面忘记了，
    
                    
    • 
                    
  • Android之权限架构
                        向上_50358291
android架构
                        
    1.权限简介：所有的权限定义在Android系统的源代码中，路径通常位于frameworks/base/core/res/AndroidManifest.xml。本篇文章以Android15原生源码来做的讲解。LI、LIF、LPr、LPw是什么？首先L代表Lock，I代表mInstall，P代表mPackages，F代表frozen，r代表读，w代表写。2.安装时权限：2.1普通权限（Normal
    
                    
    • 
                    
  • 深度探索 DeepSeek-R1：国产大模型的AGI雏形与创新进展
                        微凉的衣柜
科技头条agi人工智能
                        
    随着人工智能技术的飞速发展，国内外企业纷纷发布了一系列创新的大模型，推动了AGI（通用人工智能）领域的探索。近期，DeepSeek-R1这一模型的发布引起了广泛关注，它不仅标志着国产大模型在智能化上的一次重大突破，还提出了全新的训练方法，解决了过去依赖大量人类数据的问题。本篇文章将详细介绍DeepSeek-R1的核心优势、技术创新以及实际应用案例，揭示它在AGI领域的潜力。1.DeepSeek-R
    
                    
    • 
                    
  • 第 3 章 核心处理层（中）
                        沉登c
MyBatis技术内幕mybatisjava
                        
    3.3ResultSetHandlerMyBatis将结果集按照映射配置文件中定义的映射规则，例如节点、resultType属性等，映射成相应的结果对象。这一过程是由ResultSetHandler完成的。publicinterfaceResultSetHandler{//处理结果集，生成相应的结果对象集合ListhandleResultSets(Statementstmt)throwsSQLEx
    
                    
    • 
                    
  • 深入探讨：如何在 Debian 系统中实施有效的安全配置
                        Echo_Wish
运维探秘让你快速入坑运维debian安全运维
                        
    深入探讨：如何在Debian系统中实施有效的安全配置在如今的网络环境中，服务器的安全配置已经成为每个运维工程师的必备技能。无论是个人网站还是企业应用，确保服务器的安全性都是至关重要的。作为一名运维领域的自媒体创作者，我将分享一些在Debian系统中实施安全配置的技巧。这些技巧不仅能够提升服务器的安全性，还能帮助你防范常见的安全威胁。一、系统更新与包管理1.1定期更新系统保持系统和软件的最新状态是确
    
                    
    • 
                    
  • memcached的内存分配器是如何工作的？为什么不适用malloc/free！？为何要使用slabs？思维导图 代码示例（java 架构)
                        用心去追梦
memcachedjava架构
                        
    Memcached内存分配器工作原理Memcached使用了一种称为SlabAllocator的内存分配机制，它与传统的malloc/free不同。以下是关于为什么Memcached选择使用SlabAllocator而不是标准的内存分配方式的原因，以及其工作原理的关键点：1.SlabAllocator的优点减少碎片化：SlabAllocator通过预先分配固定大小的内存块（称为slabs），并将相
    
                    
    • 
                    
  • Linux 系统服务开机自启动指导手册
                        我科绝伦（Huanhuan Zhou）
linuxlinux服务器java
                        
    一、引言在Linux系统中，设置服务开机自启动是常见的系统配置任务。本文档详细介绍了多种实现服务开机自启动的方法，包括systemctl方式、通用脚本方式、crontab方案等，并提供了生产环境下的方案建议和开机启动脚本示例。二、systemctl方式2.1适用范围适用于已安装为系统服务且服务文件（.service）存储在/usr/lib/systemd/system的组件。2.2设置开机启动使用
    
                    
    • 
                    
  • SQL记录学习日志
                        柠檬无糖可乐
sql学习数据库
                        
    删除表DROPTABLE：彻底删除表和其数据，无法恢复。DROPTABLEIFEXISTS：在删除之前检查表是否存在。TRUNCATETABLE：删除所有数据，但保留表的结构。DELETE：删除表中的所有数据，但保留表的结构和约束。
    
                    
    • 
                    
  • 生数科技携手央视新闻《文博日历》，推动AI视频技术的创新应用
                        TMT星球
人工智能人工智能科技大数据
                        
    近日，生数科技携手央视新闻《文博日历》栏目，借助其旗下AI视频大模型及应用产品Vidu，共同打造AI版2025年文博日历联欢晚会，全面推动AI视频生成技术在媒体中的创新实践。《文博日历》是央视新闻客户端联合各大博物馆推出的文博科普产品，以新媒体形式为观众呈现丰富多彩的文博知识和历史文化。据「TMT星球」了解，此次合作中，生数科技为《文博日历》量身定制了AI视频生成方案，让文物们“动”起来，共同出演
    
                    
    • 
                    
  • 【Web3企业出海】奇墨科技为企业出海提供云安全、ITQM智能运维及云MSP一站式服务
                        奇墨 ITQM
科技运维
                        
    1月15日，Web3嘉年华在四川成都成功举办。此次活动为探索企业出海的发展及创新机遇提供平台。活动现场，奇墨科技团队与在场嘉宾共商2025年企业出海的合作创新之道。奇墨科技，作为数字化领域的积极探索者与创新实践者，聚焦安全服务、奇墨ITQM智能运维、云MSP服务，为企业出海安全提供更具核心竞争力的技术支持。.云安全：极致性价比的企业云安全托底保障有底云安是奇墨科技旗下的云安全产品品牌，有底云安搭建
    
                    
    • 
                    
  • Scala语言的循环实现
                        Code侠客行
包罗万象golang开发语言后端
                        
    Scala语言的循环实现在编程中，循环是一个非常重要的概念，它允许我们重复执行某些代码块。Scala作为一种现代化的编程语言，融合了函数式编程和面向对象编程的特点，提供了多种方式来实现循环。在本文中，我们将深入探讨Scala中的循环实现，包括基本的循环结构、使用集合与高阶函数、以及如何利用递归来实现循环。一、基础循环结构Scala提供了几种基础的循环结构，包括for循环、while循环和dowhi
    
                    
    • 
                    
  • 【江西省乡镇界】面图层shp格式乡镇名称和编码wgs84无偏移arcgis数据内容测评
                        鸿业远图科技
arcgis
                        
    标题中的“江西省乡镇界面图层shp格式乡镇名称和编码wgs84无偏移arcgis数据”指的是一份地理信息系统（GIS）的数据集，主要用于描绘江西省内各个乡镇的边界信息。这份数据集采用的是Shapefile（shp）格式，这是一种广泛用于GIS领域的矢量数据格式，可以存储地理特征的几何、属性和标识信息。其中，“乡镇名称和编码”指的是每个乡镇的专属标识，通常包括乡镇的名字和一个唯一编码，方便数据管理和
    
                    
    • 
                    
  • 天天AI-20250121：全面解读 AI 实践课程：动手学大模型（含PDF课件）
                        AI2AGI
天天AI人工智能大数据ai文心一言百度
                        
    2AGI.NET|探索AI无限潜力，2AGI为您带来最前沿资讯。2AGI.NET：天天AI-20250121从开源版o1模型的发布到Adobe推出音乐模型DITTO-2，再到OpenAI为研究长寿推出的GPT-4b，AI技术正以前所未有的速度和规模影响着我们的世界。本文将为您梳理近期的技术热点，带您一探究竟。全面解读AI实践课程：动手学大模型（含PDF课件）该教程内容较为专业，理解起来有一定难度，
    
                    
    • 
                    
  • AI界的拼多多-中国人工智能初创公司DeepSeek如何与硅谷巨头竞争
                        xidianjiapei001
AI-人工智能与大模型人工智能AIDeepSeek大模型
                        
    这家公司打造出了一款成本更低且颇具竞争力的聊天机器人，其使用的高端计算机芯片数量少于谷歌和OpenAI等美国巨头企业，这凸显出芯片出口管制的局限性。圣诞节次日，一家名为DeepSeek的中国小型初创公司推出了一款新的人工智能系统，其性能可与OpenAI和谷歌等公司的尖端聊天机器人相媲美。仅此一点就堪称一个里程碑。但这个名为DeepSeek-V3系统的研发团队称，他们迈出了更大的一步。在一篇解释该技
    
                    
    • 
                    
  • SpringBoot3+Vue3+NaiveUI博客后台管理系统源码 | 小蚂蚁云
                        小蚂蚁开源
后端vue架构低代码
                        
    项目介绍基于SpringBoot3、SpringSecurity、MybatisPlus、Vue3、TypeScript、Vite、NaiveUI、MySQL等技术栈实现的单体前后端分离后台管理系统；后端基于Java语言采用SpringBoot3、SpringSecurity、MybatisPlus、MySQL等主流技术栈，前端基于Vue3、TypeScript、Vite等技术栈实现，采用Naiv
    
                    
    • 
                    
  • 小蚂蚁云后台管理系统|XiaoMaYi
                        小蚂蚁开源
后端vue
                        
    项目介绍基于SpringBoot3、SpringSecurity、MybatisPlus、Vue3、TypeScript、Vite、ElementPlus、MySQL等技术栈实现的单体前后端分离后台管理系统；后端基于Java语言采用SpringBoot3、SpringSecurity、MybatisPlus、MySQL等主流技术栈，前端基于Vue3、TypeScript、Vite等技术栈实现，采用
    
                    
    • 
                    
  • multimap在c++的一些用法
                        wwjjjww
c++开发语言
                        
    multimap是C++标准库中一个非常有用的关联容器，用于存储键值对，其中一个键可以对应多个值。与map类似，但multimap允许相同的键有多个值。下面是multimap的用法大全，包括基本操作和常见用法示例。1.引入头文件首先，要使用multimap，需要包含头文件：#include2.定义和初始化创建multimap对象时，需要指定键和值的类型。multimapmyMultimap;3.插
    
                    
    • 
                    
  • java抽取PDF指定范围页做新的PDF文件
                        vipwangjun
epubjavajavapdfitextpdfPDF分割
                        
    因为公司有将首页提取出来做成一个单独的PDF文件.为了以后方便,直接就写一个方法.可以抽取任意范围的PDF页作为新的PDF./***截取pdfFile的第from页至第end页，组成一个新的文件名*@parampdfFile需要分割的PDF*@paramsavepath新PDF*@paramfrom起始页*@paramend结束页*/publicstaticvoidsplitPDFFile(Str
    
                    
    • 
                    
  • 将josn字符串解析成实体
                        努力，别失业
C#动态解析JSONjsonmodal
                        
    dynamic_modal=Newtonsoft.Json.Linq.JToken.Parse(_json_data)asdynamic;将json字符_json_data动态解析成实体_modal,可以直接取_modal的属性字体。JsonResultResult=(JsonResult)Pay("","","","");varjsonStr=Newtonsoft.Json.JsonConver
    
                    
    • 
                    
  • 学习AI职场应用技能的意义
                        Mieux718
学习人工智能
                        
    在智能化浪潮下，“人工智能+”通识必修课的普及，其核心并非在于培养人工智能领域的专家，而是旨在构建全民AI素养的基石。学习AI是可以让学生借助其技术力量，为各自的专业领域插上创新的翅膀。除了高校外，越来越多的企业也开始关注AI对企业业务的帮助，职场中掌握AI也变得越来越重要。随着人工智能技术的发展，许多行业都在引入相关技术和应用，人工智能应用场景已深度融入办公流程、项目管理、项目运营、客户服务等工
    
                    
    • 
                    
  • 2021最全大厂Java面试题总结，备战2022春招~~
                        老程不秃
Java面试程序员java面试架构数据结构程序人生
                        
    前言2021年已不足一月，再过不久就要迎来2022年了，相信很多小伙伴在为跳槽做准备，每年的金三银四都是各大公司招聘程序员的最佳时期，在这段时间内有好多程序员为面试而发愁，不知道如何才能收到好的offer，拿到理想的薪资，实现自我的人生价值！所以小编特地分享出总结的一份480余页的面试手册。俗话说得好，他山之石，可以攻玉，多看多借鉴希望能对大家有所帮助✌。需要原文件学习的朋友们点赞+收藏，关注我之
    
                    
    • 
                    
  • 三轴MEMS陀螺仪：创新科技，精准感知
                        艾瑞科惯性技术
技术应用科技
                        
    在智能设备日新月异的今天，传感器作为设备感知外界环境的“耳目”，其性能的提升对于设备的整体表现至关重要。艾瑞科惯性技术ER-3MG-14三轴MEMS陀螺仪凭借其出色的性能，成为了众多领域中的优选传感器，展示其在现代科技中的独特魅力。高精度测量，稳定可靠ER-3MG-14三轴MEMS陀螺仪采用先进的微机电系统（MEMS）技术，能够实现对物体围绕三个轴的旋转速度进行高精度测量。陀螺仪测量范围：200d
    
                    
    • 
                    
  • 线性代数 第七讲 二次型_标准型_规范型_坐标变换_合同_正定二次型详细讲解_重难点题型总结
                        二叉树果实
线性代数线性代数
                        
    文章目录1.二次型1.1二次型、标准型、规范型、正负惯性指数、二次型的秩1.2坐标变换1.3合同1.4正交变换化为标准型1.5可逆线性变换和正交变换1.6二次型化标准形，二次型化规范形的联系思考1.8两个二次型联系的思考1.9对于配方法问题的深入思考2.二次型的主要定理3.正定二次型与正定矩阵4.重难点题型总结4.1配方法将二次型化为标准型4.2正交变换法将二次型化为标准型4.3规范型确定取值范围
    
                    
    • 
                    
  • 使用Python将PDF文件转换为MOBI格式
                        choiiie
菜狗的怪问题合集pdfpython经验分享
                        
    使用Python将PDF文件转换为MOBI格式引言在这篇文章中，我们将学习如何使用Python创建一个图形用户界面（GUI）应用程序，将PDF文件转换为MOBI格式。我们将使用tkinter作为GUI库，PyMuPDF或PyPDF2来处理PDF文件，以及Calibre的ebook-convert命令行工具来完成文件格式的转换。GitHub项目地址这个项目已经托管在GitHub上准备工作在开始之前，
    
                    
    • 
                    
  • JsonPath用法详解
                        吴少凡
python开发语言自动化pycharm
                        
    JSONPath是一种信息抽取类库，是从JSON文档中抽取指定信息的工具，提供多种语言实现版本，包括Javascript、Python、PHP和Java。1、JSONPath安装:pipinstalljsonpath#如果安装太慢可以使用清华源来加速安装pipinstalljsonpath-ihttps://pypi.tuna.tsinghua.edu.cn/simple2、JSONPath语法J
    
                    
    • 
                    
  • dirname和basename
                        学无止境LL
Shell
                        
    简介dirname命令去除文件名中的非目录部分，仅显示与目录有关的内容。dirname命令读取指定路径名保留最后一个/及其左边的字符，删除右边部分，并写结果到标准输出。如果最后一个/之后无字符，dirname命令使用倒数第二个/，并忽略其后的所有字符。dirname和basename通常在shell内部命令替换使用，以指定一个与指定输入文件名略有差异的输出文件名。语法diename(选项)(参数)
    
                    
    • 
                    
  • python批量转化pdf图片为jpg图片
                        不懂python不懂R
pythonpythonpdf
                        
    1.把pdf图片批量转为jpg；需要注意的是，需要先安装poppler这个软件，具体安装教程放在下面代码中了2.代码#poppler安装教程参考：https://blog.csdn.net/wy01415/article/details/110257130#windows上poppler下载链接：https://github.com/oschwartz10612/poppler-windowsfr
    
                    
    • 
                    
  • golang中的包管理-下--详解
                        网络风云
后端开发语言golang
                        
    继续Golang包管理，上节发布了包管理的简介和基本概念，接下来详细介绍包管理的常用工具以及最佳实践。帮助开发者有效地管理项目中的依赖关系、版本控制、以及模块化代码。Go的包管理系统在多个版本之间有过一些变革，从早期的GOPATH到当前的GoModules，其设计目标是简化开发流程、提高开发效率并避免版本冲突。1、Golang包管理的演变GOPATH模式在Go语言的早期，Go使用的是GOPATH作
    
                    
    • 
                                
  • 多线程编程之理财
                                    周凡杨
java多线程生产者消费者理财
                                    
          现实生活中，我们一边工作，一边消费，正常情况下会把多余的钱存起来，比如存到余额宝，还可以多挣点钱，现在就有这个情况：我每月可以发工资20000万元 （暂定每月的1号），每月消费5000（租房+生活费）元（暂定每月的1号），其中租金是大头占90%，交房租的方式可以选择（一月一交，两月一交、三月一交），理财：1万元存余额宝一天可以赚1元钱，
    
                                
    • 
                                
  • [Zookeeper学习笔记之三]Zookeeper会话超时机制
                                    bit1129
zookeeper
                                    
    首先，会话超时是由Zookeeper服务端通知客户端会话已经超时，客户端不能自行决定会话已经超时，不过客户端可以通过调用Zookeeper.close()主动的发起会话结束请求，如下的代码输出内容 
Created /zoo-739160015 
CONNECTEDCONNECTED 
.............CONNECTEDCONNECTED 
CONNECTEDCLOSEDCLOSED 

    
                                
    • 
                                
  • SecureCRT快捷键
                                    daizj
secureCRT快捷键
                                    
    ctrl + a : 移动光标到行首ctrl + e ：移动光标到行尾crtl + b: 光标前移1个字符crtl + f: 光标后移1个字符crtl + h : 删除光标之前的一个字符ctrl + d ：删除光标之后的一个字符crtl + k ：删除光标到行尾所有字符crtl + u : 删除光标至行首所有字符crtl + w:  删除光标至行首
    
                                
    • 
                                
  • Java 子类与父类这间的转换
                                    周凡杨
java 父类与子类的转换
                                    
        最近同事调的一个服务报错，查看后是日期之间转换出的问题。代码里是把 java.sql.Date 类型的对象 强制转换为 java.sql.Timestamp 类型的对象。报java.lang.ClassCastException。 
  
    代码： 
            
    
                                
    • 
                                
  • 可视化swing界面编辑
                                    朱辉辉33
eclipseswing
                                    
          今天发现了一个WindowBuilder插件，功能好强大，啊哈哈，从此告别手动编辑swing界面代码，直接像VB那样编辑界面，代码会自动生成。 
      首先在Eclipse中点击help，选择Install New Software,然后在Work with中输入WindowBui
    
                                
    • 
                                
  • web报表工具FineReport常用函数的用法总结（文本函数）
                                    老A不折腾
finereportweb报表工具报表软件java报表
                                    
    文本函数 
CHAR 
CHAR(number):根据指定数字返回对应的字符。CHAR函数可将计算机其他类型的数字代码转换为字符。 
Number:用于指定字符的数字，介于1Number:用于指定字符的数字，介于165535之间（包括1和65535）。 
示例: 
CHAR(88)等于“X”。 
CHAR(45)等于“-”。 
  
CODE 
CODE(text):计算文本串中第一个字
    
                                
    • 
                                
  • mysql安装出错
                                    林鹤霄
mysql安装
                                    
    [root@localhost ~]# rpm -ivh MySQL-server-5.5.24-1.linux2.6.x86_64.rpm Preparing...                #####################
    
                                
    • 
                                
  • linux下编译libuv
                                    aigo
libuv
                                    
    下载最新版本的libuv源码，解压后执行： 
./autogen.sh 
  
这时会提醒找不到automake命令，通过一下命令执行安装（redhat系用yum，Debian系用apt-get）： 
# yum -y install automake 
# yum -y install libtool 
  
  
如果提示错误：make: *** No targe
    
                                
    • 
                                
  • 中国行政区数据及三级联动菜单
                                    alxw4616

                                    
    近期做项目需要三级联动菜单,上网查了半天竟然没有发现一个能直接用的! 
呵呵,都要自己填数据....我了个去这东西麻烦就麻烦的数据上. 
哎,自己没办法动手写吧. 
现将这些数据共享出了,以方便大家.嗯,代码也可以直接使用 
  文件说明 
 
 lib\area.sql -- 县及县以上行政区划分代码（截止2013年8月31日)来源：国家统计局 发布时间：2014-01-17 15:0
    
                                
    • 
                                
  • 哈夫曼加密文件
                                    百合不是茶
哈夫曼压缩哈夫曼加密二叉树
                                    
     在上一篇介绍过哈夫曼编码的基础知识,下面就直接介绍使用哈夫曼编码怎么来做文件加密或者压缩与解压的软件,对于新手来是有点难度的,主要还是要理清楚步骤; 
  
加密步骤: 
 1,统计文件中字节出现的次数,作为权值 
  
2,创建节点和哈夫曼树 
  
3,得到每个子节点01串 
  
4,使用哈夫曼编码表示每个字节 
  

    
                                
    • 
                                
  • JDK1.5 Cyclicbarrier实例
                                    bijian1013
javathreadjava多线程Cyclicbarrier
                                    
    CyclicBarrier类 
一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环的 barrier。 
CyclicBarrier支持一个可选的 Runnable 命令，
    
                                
    • 
                                
  • 九项重要的职业规划
                                    bijian1013
工作学习
                                    
    一. 学习的步伐不停止        古人说，活到老，学到老。终身学习应该是您的座右铭。        世界在不断变化，每个人都在寻找各自的事业途径。        您只有保证了足够的技能储
    
                                
    • 
                                
  • 【Java范型四】范型方法
                                    bit1129
java
                                    
    范型参数不仅仅可以用于类型的声明上，例如 
  
package com.tom.lang.generics;

import java.util.List;

public class Generics<T> {
    private T value;
    public Generics(T  value) {
        this.value = 
    
                                
    • 
                                
  • 【Hadoop十三】HDFS Java API基本操作
                                    bit1129
hadoop
                                    
      
package com.examples.hadoop;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoo
    
                                
    • 
                                
  • ua实现split字符串分隔
                                    ronin47
lua split
                                    
    LUA并不象其它许多"大而全"的语言那样，包括很多功能，比如网络通讯、图形界面等。但是LUA可以很容易地被扩展：由宿主语言(通常是C或 C++)提供这些功能，LUA可以使用它们，就像是本来就内置的功能一样。LUA只包括一个精简的核心和最基本的库。这使得LUA体积小、启动速度快，从 而适合嵌入在别的程序里。因此在lua中并没有其他语言那样多的系统函数。习惯了其他语言的字符串分割函
    
                                
    • 
                                
  • java-从先序遍历和中序遍历重建二叉树
                                    bylijinnan
java
                                    
    

public class BuildTreePreOrderInOrder {

	/**
	 * Build Binary Tree from PreOrder and InOrder
	 *  _______7______
       /              \
    __10__          ___2
   /      \        /
   4
    
                                
    • 
                                
  • openfire开发指南《连接和登陆》
                                    开窍的石头
openfire开发指南smack
                                    
    第一步 
    官网下载smack.jar包 
    下载地址：http://www.igniterealtime.org/downloads/index.jsp#smack 
第二步 
    把smack里边的jar导入你新建的java项目中 
 
开始编写smack连接openfire代码 
 
p
    
                                
    • 
                                
  • [移动通讯]手机后盖应该按需要能够随时开启
                                    comsci
移动
                                    
        看到新的手机，很多由金属材质做的外壳，内存和闪存容量越来越大，CPU速度越来越快，对于这些改进，我们非常高兴，也非常欢迎 
 
     但是，对于手机的新设计，有几点我们也要注意 
 
     第一：手机的后盖应该能够被用户自行取下来，手机的电池的可更换性应该是必须保留的设计,
    
                                
    • 
                                
  • 20款国外知名的php开源cms系统
                                    cuiyadll
cms
                                    
    内容管理系统，简称CMS，是一种简易的发布和管理新闻的程序。用户可以在后端管理系统中发布，编辑和删除文章，即使您不需要懂得HTML和其他脚本语言，这就是CMS的优点。 
在这里我决定介绍20款目前国外市面上最流行的开源的PHP内容管理系统，以便没有PHP知识的读者也可以通过国外内容管理系统建立自己的网站。 
1. Wordpress 
WordPress的是一个功能强大且易于使用的内容管
    
                                
    • 
                                
  • Java生成全局唯一标识符
                                    darrenzhu
javauuiduniqueidentifierid
                                    
    How to generate a globally unique identifier in Java 
 
 
 
http://stackoverflow.com/questions/21536572/generate-unique-id-in-java-to-label-groups-of-related-entries-in-a-log 
 
 
http://stackoverflow
    
                                
    • 
                                
  • php安装模块检测是否已安装过, 使用的SQL语句
                                    dcj3sjt126com
sql
                                    
           
SHOW [FULL] TABLES [FROM db_name] [LIKE 'pattern'] 
SHOW TABLES列举了给定数据库中的非TEMPORARY表。您也可以使用mysqlshow db_name命令得到此清单。 
本命令也列举数据库中的其它视图。支持FULL修改符，这样SHOW FULL TABLES就可以显示第二个输出列。对于一个表，第二列的值为BASE T
    
                                
    • 
                                
  • 5天学会一种 web 开发框架
                                    dcj3sjt126com
Web框架framework
                                    
    web framework层出不穷，特别是ruby/python,各有10+个,php/java也是一大堆 根据我自己的经验写了一个to do list,按照这个清单，一条一条的学习，事半功倍，很快就能掌握 一共25条，即便很磨蹭，2小时也能搞定一条，25*2=50。只需要50小时就能掌握任意一种web框架 
各类web框架大同小异:现代web开发框架的6大元素，把握主线，就不会迷路 
建议把本文
    
                                
    • 
                                
  • Gson使用三(Map集合的处理,一对多处理)
                                    eksliang
jsongsonGson mapGson 集合处理
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2175532 一、概述 
       Map保存的是键值对的形式，Json的格式也是键值对的，所以正常情况下，map跟json之间的转换应当是理所当然的事情。 二、Map参考实例 
package com.ickes.json;

import java.lang.refl
    
                                
    • 
                                
  • cordova实现“再点击一次退出”效果
                                    gundumw100
android
                                    
    基本的写法如下： 
 


document.addEventListener("deviceready", onDeviceReady, false);
			
function onDeviceReady() {
	//navigator.splashscreen.hide();
        document.addEventListener("b
    
                                
    • 
                                
  • openldap configuration leaning note
                                    iwindyforest
configuration
                                    
    hostname // to display the computer name 
hostname <changed name> // to change 
go to: /etc/sysconfig/network, add/modify HOSTNAME=NEWNAME to change permenately 
dont forget to change /etc/hosts
    
                                
    • 
                                
  • Nullability and Objective-C
                                    啸笑天
Objective-C
                                    
    https://developer.apple.com/swift/blog/?id=25 
  
http://www.cocoachina.com/ios/20150601/11989.html 
  
http://blog.csdn.net/zhangao0086/article/details/44409913 
  
http://blog.sunnyxx
    
                                
    • 
                                
  • jsp中实现参数隐藏的两种方法
                                    macroli
JavaScriptjsp
                                    
    在一个JSP页面有一个链接，//确定是一个链接?点击弹出一个页面，需要传给这个页面一些参数。//正常的方法是设置弹出页面的src="***.do?p1=aaa&p2=bbb&p3=ccc"//确定目标URL是Action来处理?但是这样会在页面上看到传过来的参数，可能会不安全。要求实现src="***.do"，参数通过其他方法传！//////
    
                                
    • 
                                
  • Bootstrap A标签关闭modal并打开新的链接解决方案
                                    qiaolevip
每天进步一点点学习永无止境bootstrap纵观千象
                                    
    Bootstrap里面的js modal控件使用起来很方便，关闭也很简单。只需添加标签 data-dismiss="modal" 即可。 
可是偏偏有时候需要a标签既要关闭modal，有要打开新的链接，尝试多种方法未果。只好使用原始js来控制。 
  
<a href="#/group-buy" class="btn bt
    
                                
    • 
                                
  • 二维数组在Java和C中的区别
                                    流淚的芥末
javac二维数组数组
                                    
    Java代码： 
  
public class test03 {
	public static void main(String[] args) {
		int[][] a = {{1},{2,3},{4,5,6}};
		System.out.println(a[0][1]);
	}
} 
 运行结果： 
Exception in thread "mai
    
                                
    • 
                                
  • systemctl命令用法
                                    wmlJava
linuxsystemctl
                                    
    对比表，以 apache / httpd 为例   任务 旧指令 新指令   使某服务自动启动 chkconfig --level 3 httpd on systemctl enable httpd.service   使某服务不自动启动 chkconfig --level 3 httpd off systemctl disable httpd.service   检查服务状态 service h
    
                                
    •