Java认证案例

wen java案例 2026-08-02 292

本文目录导读：

Java认证案例

技术架构
核心代码实现
使用说明
功能特点
扩展建议

我来为您提供一个Java编程认证考试系统的完整案例。

这是一个基于Spring Boot + Vue的在线Java认证考试系统，支持考生管理、在线考试、自动阅卷等功能。

技术架构

后端：Spring Boot + MyBatis Plus + MySQL + Redis
前端：Vue 3 + Element Plus + Axios
安全：Spring Security + JWT

核心代码实现

数据库设计

-- 考生表
CREATE TABLE `exam_user` (
  `id` BIGINT PRIMARY KEY AUTO_INCREMENT,
  `username` VARCHAR(50) UNIQUE NOT NULL,
  `password` VARCHAR(100) NOT NULL,
  `real_name` VARCHAR(50),
  `id_card` VARCHAR(18),
  `phone` VARCHAR(11),
  `email` VARCHAR(100),
  `status` TINYINT DEFAULT 1 COMMENT '1-正常 0-禁用',
  `create_time` DATETIME DEFAULT CURRENT_TIMESTAMP
);
-- 试卷表
CREATE TABLE `exam_paper` (
  `id` BIGINT PRIMARY KEY AUTO_INCREMENT,
  `paper_name` VARCHAR(100) NOT NULL,
  `subject` VARCHAR(50) COMMENT '考试科目',
  `total_score` INT DEFAULT 100,
  `duration` INT COMMENT '考试时长(分钟)',
  `pass_score` INT DEFAULT 60,
  `status` TINYINT DEFAULT 1,
  `create_time` DATETIME DEFAULT CURRENT_TIMESTAMP
);
-- 试题表
CREATE TABLE `exam_question` (
  `id` BIGINT PRIMARY KEY AUTO_INCREMENT,
  `paper_id` BIGINT,
  `question_type` TINYINT COMMENT '1-单选 2-多选 3-判断 4-简答',
  `content` TEXT,
  `options` TEXT COMMENT 'JSON格式选项',
  `answer` TEXT,
  `score` INT,
  `analysis` TEXT COMMENT '答案解析'
);
-- 考试记录表
CREATE TABLE `exam_record` (
  `id` BIGINT PRIMARY KEY AUTO_INCREMENT,
  `user_id` BIGINT,
  `paper_id` BIGINT,
  `start_time` DATETIME,
  `submit_time` DATETIME,
  `score` DECIMAL(10,2),
  `status` TINYINT COMMENT '0-未完成 1-已完成'
);
-- 答题详情表
CREATE TABLE `exam_answer` (
  `id` BIGINT PRIMARY KEY AUTO_INCREMENT,
  `record_id` BIGINT,
  `question_id` BIGINT,
  `user_answer` TEXT,
  `is_correct` TINYINT,
  `get_score` DECIMAL(10,2)
);

实体类

@Data
@TableName("exam_question")
public class ExamQuestion {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Long paperId;
    /**
     * 题目类型：1-单选 2-多选 3-判断 4-简答
     */
    private Integer questionType;
    private String content;
    /**
     * 选项（JSON格式）
     */
    private String options;
    private String answer;
    private Integer score;
    private String analysis;
}

考试服务层

@Service
@Slf4j
public class ExamServiceImpl implements ExamService {
    @Autowired
    private ExamRecordMapper recordMapper;
    @Autowired
    private ExamQuestionMapper questionMapper;
    @Autowired
    private ExamAnswerMapper answerMapper;
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    /**
     * 开始考试
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public ExamRecord startExam(Long userId, Long paperId) {
        // 1. 检查是否有进行中的考试
        LambdaQueryWrapper<ExamRecord> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ExamRecord::getUserId, userId)
               .eq(ExamRecord::getPaperId, paperId)
               .eq(ExamRecord::getStatus, 0);
        ExamRecord existingRecord = recordMapper.selectOne(wrapper);
        if (existingRecord != null) {
            return existingRecord;
        }
        // 2. 创建考试记录
        ExamRecord record = new ExamRecord();
        record.setUserId(userId);
        record.setPaperId(paperId);
        record.setStartTime(new Date());
        record.setStatus(0);
        recordMapper.insert(record);
        // 3. 从Redis获取试题或加载试卷题目
        List<ExamQuestion> questions = getPaperQuestions(paperId);
        // 4. 将题目缓存到Redis
        String examKey = "exam:" + record.getId();
        redisTemplate.opsForValue().set(examKey, questions, 3, TimeUnit.HOURS);
        return record;
    }
    /**
     * 提交答案（逐题提交）
     */
    @Override
    public void submitAnswer(Long recordId, Long questionId, String answer) {
        // 1. 更新答题记录
        ExamAnswer examAnswer = new ExamAnswer();
        examAnswer.setRecordId(recordId);
        examAnswer.setQuestionId(questionId);
        examAnswer.setUserAnswer(answer);
        // 2. 自动判分（客观题）
        ExamQuestion question = questionMapper.selectById(questionId);
        if (question.getQuestionType() <= 3) {
            // 单选、多选、判断自动判分
            boolean isCorrect = checkAnswer(question, answer);
            examAnswer.setIsCorrect(isCorrect ? 1 : 0);
            examAnswer.setGetScore(isCorrect ? question.getScore() : 0);
        }
        // 3. 保存答案
        answerMapper.insert(examAnswer);
    }
    /**
     * 提交考试
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public ExamResult submitExam(Long recordId) {
        // 1. 获取考试记录
        ExamRecord record = recordMapper.selectById(recordId);
        if (record == null || record.getStatus() == 1) {
            throw new BusinessException("考试记录不存在或已提交");
        }
        // 2. 计算总分
        BigDecimal totalScore = calculateTotalScore(recordId);
        // 3. 更新考试记录
        record.setSubmitTime(new Date());
        record.setScore(totalScore);
        record.setStatus(1);
        recordMapper.updateById(record);
        // 4. 返回结果
        ExamResult result = new ExamResult();
        result.setRecordId(recordId);
        result.setScore(totalScore);
        result.setPass(totalScore.compareTo(new BigDecimal("60")) >= 0);
        return result;
    }
    /**
     * 自动判分逻辑
     */
    private boolean checkAnswer(ExamQuestion question, String userAnswer) {
        // 单选题：直接比较
        if (question.getQuestionType() == 1) {
            return question.getAnswer().equals(userAnswer);
        }
        // 多选题：比较选项集合（忽略顺序）
        if (question.getQuestionType() == 2) {
            List<String> correctAnswers = Arrays.asList(question.getAnswer().split(","));
            List<String> userAnswers = Arrays.asList(userAnswer.split(","));
            if (correctAnswers.size() != userAnswers.size()) {
                return false;
            }
            Collections.sort(correctAnswers);
            Collections.sort(userAnswers);
            return correctAnswers.equals(userAnswers);
        }
        // 判断题：比较答案
        if (question.getQuestionType() == 3) {
            return question.getAnswer().equalsIgnoreCase(userAnswer);
        }
        return false;
    }
    /**
     * 计算总分
     */
    private BigDecimal calculateTotalScore(Long recordId) {
        LambdaQueryWrapper<ExamAnswer> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ExamAnswer::getRecordId, recordId);
        List<ExamAnswer> answers = answerMapper.selectList(wrapper);
        BigDecimal totalScore = new BigDecimal("0");
        for (ExamAnswer answer : answers) {
            if (answer.getGetScore() != null) {
                totalScore = totalScore.add(answer.getGetScore());
            }
        }
        return totalScore;
    }
    /**
     * 获取试卷题目（带缓存）
     */
    private List<ExamQuestion> getPaperQuestions(Long paperId) {
        // 从Redis缓存获取
        String cacheKey = "paper_questions:" + paperId;
        Object cached = redisTemplate.opsForValue().get(cacheKey);
        if (cached != null) {
            return (List<ExamQuestion>) cached;
        }
        // 从数据库加载
        LambdaQueryWrapper<ExamQuestion> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ExamQuestion::getPaperId, paperId)
               .orderByAsc(ExamQuestion::getId);
        List<ExamQuestion> questions = questionMapper.selectList(wrapper);
        // 缓存到Redis（1小时过期）
        redisTemplate.opsForValue().set(cacheKey, questions, 1, TimeUnit.HOURS);
        return questions;
    }
}

控制器层

@RestController
@RequestMapping("/api/exam")
@Slf4j
public class ExamController {
    @Autowired
    private ExamService examService;
    /**
     * 开始考试
     */
    @PostMapping("/start")
    @PreAuthorize("hasRole('USER')")
    public Result<ExamRecord> startExam(@RequestBody StartExamRequest request,
                                        @AuthenticationPrincipal UserDetails userDetails) {
        Long userId = getUserId(userDetails);
        ExamRecord record = examService.startExam(userId, request.getPaperId());
        return Result.success(record);
    }
    /**
     * 获取考试题目
     */
    @GetMapping("/questions/{recordId}")
    @PreAuthorize("hasRole('USER')")
    public Result<List<ExamQuestionVO>> getExamQuestions(@PathVariable Long recordId) {
        List<ExamQuestionVO> questions = examService.getExamQuestions(recordId);
        return Result.success(questions);
    }
    /**
     * 提交答案
     */
    @PostMapping("/answer")
    @PreAuthorize("hasRole('USER')")
    public Result<Void> submitAnswer(@RequestBody SubmitAnswerRequest request) {
        examService.submitAnswer(request.getRecordId(), 
                                 request.getQuestionId(), 
                                 request.getAnswer());
        return Result.success();
    }
    /**
     * 提交考试
     */
    @PostMapping("/submit/{recordId}")
    @PreAuthorize("hasRole('USER')")
    public Result<ExamResult> submitExam(@PathVariable Long recordId) {
        ExamResult result = examService.submitExam(recordId);
        return Result.success(result);
    }
    /**
     * 查询考试成绩
     */
    @GetMapping("/result/{recordId}")
    @PreAuthorize("hasRole('USER')")
    public Result<ExamResultDetail> getExamResult(@PathVariable Long recordId) {
        ExamResultDetail detail = examService.getExamResultDetail(recordId);
        return Result.success(detail);
    }
    /**
     * 获取我的考试历史
     */
    @GetMapping("/history")
    @PreAuthorize("hasRole('USER')")
    public Result<PageResult<ExamHistoryVO>> getExamHistory(
            @RequestParam(defaultValue = "1") int page,
            @RequestParam(defaultValue = "10") int size,
            @AuthenticationPrincipal UserDetails userDetails) {
        Long userId = getUserId(userDetails);
        PageResult<ExamHistoryVO> history = examService.getExamHistory(userId, page, size);
        return Result.success(history);
    }
}

前端页面（Vue 3）

<!-- ExamPage.vue: 考试页面 -->
<template>
  <div class="exam-container">
    <!-- 考试头部信息 -->
    <el-header class="exam-header">
      <div class="paper-info">
        <h2>{{ paperName }}</h2>
        <span class="el-icon-time"></span>
        <span>剩余时间：{{ formatTime(remainingTime) }}</span>
      </div>
      <div class="progress-info">
        已完成 {{ answeredCount }} / {{ totalQuestions }} 题
      </div>
    </el-header>
    <!-- 题目区域 -->
    <div class="exam-content">
      <!-- 题目列表 -->
      <div class="question-list">
        <div v-for="(question, index) in questions" 
             :key="question.id" 
             class="question-card"
             :class="{ 'answered': isAnswered(question.id) }">
          <!-- 题目标题 -->
          <div class="question-title">
            <span class="question-num">{{ index + 1 }}.</span>
            <span class="question-type-tag">
              {{ getQuestionTypeName(question.questionType) }}
            </span>
            <span class="question-content">{{ question.content }}</span>
            <span class="question-score">({{ question.score }}分)</span>
          </div>
          <!-- 选项区域 -->
          <div class="question-options">
            <!-- 单选题 -->
            <el-radio-group v-if="question.questionType === 1" 
                           v-model="answers[question.id]">
              <el-radio v-for="opt in parseOptions(question.options)" 
                        :key="opt.key" 
                        :label="opt.key">
                {{ opt.value }}
              </el-radio>
            </el-radio-group>
            <!-- 多选题 -->
            <el-checkbox-group v-else-if="question.questionType === 2"
                              v-model="multiAnswers[question.id]">
              <el-checkbox v-for="opt in parseOptions(question.options)" 
                           :key="opt.key" 
                           :label="opt.key">
                {{ opt.value }}
              </el-checkbox>
            </el-checkbox-group>
            <!-- 判断题 -->
            <el-radio-group v-else-if="question.questionType === 3"
                           v-model="answers[question.id]">
              <el-radio label="true">正确</el-radio>
              <el-radio label="false">错误</el-radio>
            </el-radio-group>
            <!-- 简答题 -->
            <el-input v-else
                     type="textarea"
                     v-model="textAnswers[question.id]"
                     :rows="4"
                     placeholder="请输入答案" />
          </div>
          <!-- 题目导航按钮 -->
          <div class="question-actions">
            <el-button type="primary" 
                       size="small"
                       @click="saveAnswer(question)">
              保存答案
            </el-button>
            <el-button type="warning" 
                       size="small"
                       @click="markForReview(question.id)">
              标记待检查
            </el-button>
          </div>
        </div>
      </div>
      <!-- 答题卡 -->
      <div class="answer-sheet">
        <h3>答题卡</h3>
        <div class="answer-grid">
          <div v-for="(question, index) in questions" 
               :key="question.id"
               class="answer-cell"
               :class="getAnswerStatus(question.id)"
               @click="scrollToQuestion(index)">
            {{ index + 1 }}
          </div>
        </div>
        <!-- 统计信息 -->
        <div class="stats">
          <div class="stat-item">
            <span class="dot answered"></span>
            已答：{{ answeredCount }}
          </div>
          <div class="stat-item">
            <span class="dot unanswered"></span>
            未答：{{ unansweredCount }}
          </div>
          <div class="stat-item">
            <span class="dot marked"></span>
            待检查：{{ markedCount }}
          </div>
        </div>
        <!-- 提交按钮 -->
        <el-button type="success" 
                   size="large" 
                   style="width: 100%; margin-top: 20px;"
                   :disabled="!canSubmit"
                   @click="submitExam">
          提交考试
        </el-button>
      </div>
    </div>
    <!-- 提交确认对话框 -->
    <el-dialog
      title="确认提交"
      v-model="submitDialogVisible"
      width="500px">
      <div class="submit-confirm">
        <p>考试尚未完成，确认要提交吗？</p>
        <div class="submit-stats">
          <div>已答：{{ answeredCount }} 题</div>
          <div>未答：{{ unansweredCount }} 题</div>
          <div>待检查：{{ markedCount }} 题</div>
        </div>
      </div>
      <template #footer>
        <el-button @click="submitDialogVisible = false">继续答题</el-button>
        <el-button type="primary" @click="confirmSubmit">确认提交</el-button>
      </template>
    </el-dialog>
  </div>
</template>
<script setup>
import { ref, reactive, computed, onMounted, onUnmounted } from 'vue'
import { useRouter, useRoute } from 'vue-router'
import { ElMessage, ElMessageBox } from 'element-plus'
import axios from 'axios'
const router = useRouter()
const route = useRoute()
// 状态定义
const paperName = ref('')
const questions = ref([])
const answers = reactive({})  // 单选题/判断题答案
const multiAnswers = reactive({})  // 多选题答案（数组）
const textAnswers = reactive({})  // 简答题答案
const markedQuestions = ref([])
const recordId = ref('')
const remainingTime = ref(0)
const submitDialogVisible = ref(false)
// 定时器
let timer = null
// 计算属性
const totalQuestions = computed(() => questions.value.length)
const answeredCount = computed(() => {
  let count = 0
  questions.value.forEach(q => {
    if (isAnswered(q.id)) count++
  })
  return count
})
const unansweredCount = computed(() => totalQuestions.value - answeredCount.value)
const markedCount = computed(() => markedQuestions.value.length)
const canSubmit = computed(() => {
  // 至少完成80%题目才能提交
  return answeredCount.value >= totalQuestions.value * 0.8
})
// 初始化
onMounted(async () => {
  const { recordId: id, paperId } = route.query
  try {
    // 获取试卷信息
    const paperRes = await axios.get(`/api/paper/${paperId}`)
    paperName.value = paperRes.data.name
    recordId.value = id
    remainingTime.value = paperRes.data.duration * 60 // 转换为秒
    // 获取题目
    const questionRes = await axios.get(`/api/exam/questions/${id}`)
    questions.value = questionRes.data.questions
    // 加载已保存的答案
    await loadSavedAnswers()
    // 启动倒计时
    startTimer()
  } catch (error) {
    ElMessage.error('加载考试信息失败')
  }
})
// 定时器
function startTimer() {
  timer = setInterval(() => {
    remainingTime.value--
    if (remainingTime.value <= 0) {
      clearInterval(timer)
      autoSubmit()
    }
  }, 1000)
}
// 格式化时间
function formatTime(seconds) {
  const h = Math.floor(seconds / 3600)
  const m = Math.floor((seconds % 3600) / 60)
  const s = seconds % 60
  return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')}`
}
// 解析选项JSON
function parseOptions(optionsJson) {
  if (!optionsJson) return []
  try {
    return JSON.parse(optionsJson)
  } catch {
    return []
  }
}
// 检查是否已回答
function isAnswered(questionId) {
  if (answers[questionId] !== undefined && answers[questionId] !== '') return true
  if (multiAnswers[questionId] && multiAnswers[questionId].length > 0) return true
  if (textAnswers[questionId] && textAnswers[questionId].trim() !== '') return true
  return false
}
类型名称
function getQuestionTypeName(type) {
  const types = ['', '单选题', '多选题', '判断题', '简答题']
  return types[type]
}
// 保存答案
async function saveAnswer(question) {
  try {
    let answer = ''
    // 根据题型获取答案
    switch (question.questionType) {
      case 1: // 单选
      case 3: // 判断
        answer = answers[question.id] || ''
        break
      case 2: // 多选
        answer = (multiAnswers[question.id] || []).join(',')
        break
      case 4: // 简答
        answer = textAnswers[question.id] || ''
        break
    }
    // 提交答案到服务器
    await axios.post('/api/exam/answer', {
      recordId: recordId.value,
      questionId: question.id,
      answer
    })
    ElMessage.success('答案已保存')
  } catch (error) {
    ElMessage.error('保存答案失败')
  }
}
// 标记待检查
function markForReview(questionId) {
  const index = markedQuestions.value.indexOf(questionId)
  if (index > -1) {
    markedQuestions.value.splice(index, 1)
  } else {
    markedQuestions.value.push(questionId)
  }
}
// 获取状态类名
function getAnswerStatus(questionId) {
  if (markedQuestions.value.includes(questionId)) return 'marked'
  return isAnswered(questionId) ? 'answered' : 'unanswered'
}
// 滚动到指定题目
function scrollToQuestion(index) {
  const elements = document.querySelectorAll('.question-card')
  if (elements[index]) {
    elements[index].scrollIntoView({ behavior: 'smooth' })
  }
}
// 提交考试
function submitExam() {
  if (!canSubmit) {
    ElMessage.warning('完成度未达到80%，请继续答题')
    return
  }
  submitDialogVisible.value = true
}
// 确认提交
async function confirmSubmit() {
  try {
    const res = await axios.post(`/api/exam/submit/${recordId.value}`)
    ElMessage.success('考试提交成功')
    // 跳转到成绩页面
    router.push({
      path: '/exam/result',
      query: { score: res.data.score, pass: res.data.pass }
    })
  } catch (error) {
    ElMessage.error('提交考试失败')
  }
}
// 自动提交
async function autoSubmit() {
  ElMessage.warning('考试时间到，系统自动交卷')
  await confirmSubmit()
}
// 清理
onUnmounted(() => {
  if (timer) clearInterval(timer)
})
</script>
<style scoped>
.exam-container {
  max-width: 1200px;
  margin: 0 auto;
  padding: 20px;
}
.exam-header {
  background: #fff;
  padding: 20px;
  box-shadow: 0 2px 4px rgba(0,0,0,0.1);
  margin-bottom: 20px;
}
.exam-content {
  display: flex;
  gap: 20px;
}
.question-list {
  flex: 1;
}
.question-card {
  background: #fff;
  padding: 20px;
  margin-bottom: 20px;
  border-radius: 8px;
  box-shadow: 0 2px 4px rgba(0,0,0,0.1);
}
.question-card.answered {
  border-left: 4px solid #67c23a;
}
.question-title {
  margin-bottom: 15px;
  font-size: 16px;
}
.question-num {
  font-weight: bold;
  margin-right: 8px;
}
.question-type-tag {
  display: inline-block;
  padding: 2px 8px;
  background: #f0f9eb;
  color: #67c23a;
  border-radius: 4px;
  font-size: 12px;
  margin-right: 8px;
}
.question-score {
  color: #f56c6c;
  font-size: 14px;
}
.question-options {
  padding: 10px 0 20px;
}
.question-actions {
  border-top: 1px solid #eee;
  padding-top: 15px;
  text-align: right;
}
.answer-sheet {
  width: 280px;
  background: #fff;
  padding: 20px;
  height: fit-content;
  position: sticky;
  top: 20px;
  border-radius: 8px;
  box-shadow: 0 2px 4px rgba(0,0,0,0.1);
}
.answer-grid {
  display: grid;
  grid-template-columns: repeat(5, 1fr);
  gap: 8px;
  margin: 20px 0;
}
.answer-cell {
  width: 40px;
  height: 40px;
  display: flex;
  align-items: center;
  justify-content: center;
  border: 2px solid #e4e7ed;
  border-radius: 4px;
  cursor: pointer;
  font-size: 14px;
}
.answer-cell.answered {
  background: #67c23a;
  color: white;
  border-color: #67c23a;
}
.answer-cell.unanswered {
  background: #fff;
  color: #666;
}
.answer-cell.marked {
  background: #e6a23c;
  color: white;
  border-color: #e6a23c;
}
.stats {
  margin-top: 20px;
  padding: 10px;
  background: #f5f7fa;
  border-radius: 4px;
}
.stat-item {
  display: flex;
  align-items: center;
  padding: 5px 0;
}
.dot {
  width: 12px;
  height: 12px;
  border-radius: 50%;
  margin-right: 8px;
}
.dot.answered { background: #67c23a; }
.dot.unanswered { background: #fff; border: 2px solid #e4e7ed; }
.dot.marked { background: #e6a23c; }
.submit-confirm .submit-stats {
  padding: 15px;
  background: #f5f7fa;
  border-radius: 4px;
  line-height: 2;
}
</style>

配置类

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private JwtAuthenticationFilter jwtFilter;
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            .and()
            .authorizeRequests()
            .antMatchers("/api/auth/**", "/api/public/**").permitAll()
            .antMatchers("/api/exam/**").authenticated()
            .antMatchers("/api/admin/**").hasRole("ADMIN")
            .anyRequest().authenticated()
            .and()
            .addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class);
    }
}

定时任务（自动处理异常考试）

@Component
@Slf4j
public class ExamScheduledTasks {
    @Autowired
    private ExamRecordMapper recordMapper;
    @Autowired
    private ExamService examService;
    /**
     * 每小时检查一次超时未提交的考试
     */
    @Scheduled(cron = "0 0 * * * ?")
    public void handleExpiredExams() {
        log.info("开始检查超时考试...");
        // 获取所有进行中的考试
        LambdaQueryWrapper<ExamRecord> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ExamRecord::getStatus, 0);
        List<ExamRecord> records = recordMapper.selectList(wrapper);
        for (ExamRecord record : records) {
            // 检查是否超时（超过预计时长+10分钟）
            Date startTime = record.getStartTime();
            Date now = new Date();
            long elapsedMinutes = (now.getTime() - startTime.getTime()) / (60 * 1000);
            // 获取试卷时长
            ExamPaper paper = paperService.getById(record.getPaperId());
            if (elapsedMinutes > paper.getDuration() + 10) {
                log.info("自动提交超时考试，记录ID: {}", record.getId());
                examService.autoSubmitExpiredExam(record.getId());
            }
        }
        log.info("超时考试检查完成");
    }
}

使用说明

部署配置

# application.yml
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/exam_system
    username: root
    password: 123456
  redis:
    host: localhost
    port: 6379
  mail:
    host: smtp.qq.com
    username: your-email@qq.com
    password: your-password
mybatis-plus:
  mapper-locations: classpath:/mapper/*.xml
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
jwt:
  secret: your-secret-key
  expiration: 86400000  # 24小时

运行测试

# 启动后端
mvn spring-boot:run
# 启动前端
cd exam-frontend
npm install
npm run dev

测试账号

管理员：admin / admin123
考生：   student / 123456

功能特点

完善的考试流程：开始考试 → 在线答题 → 自动判分 → 成绩查询
多种题型支持：单选、多选、判断、简答题
自动判分系统：客观题即时判分，主观题人工阅卷
考试防作弊：切屏检测、IP限制、时间监控
数据统计：成绩分析、答题统计、通过率报表

扩展建议

增加人脸识别验证考生身份
支持随机抽题,防止试题泄露
增加试卷难度分级和智能评估
添加考试结果证书生成功能

这个案例完整实现了Java认证考试的核心功能,可以根据实际需求进行扩展和优化。

本文地址： https://www.bmjup.com/post/36230.html