在线 OJ 系统竞赛管理模块开发实战 (Java-Spring) | 极客日志

Java大前端java算法

在线 OJ 系统竞赛管理模块开发实战 (Java-Spring)

在线 OJ 系统竞赛管理模块涵盖数据建模、列表查询、竞赛创建及状态流转。通过 Java-Spring Boot 构建后端服务，利用 MyBatis Plus 处理复杂查询与批量操作；前端采用 Vue 配合 Element Plus 实现交互。重点解决长整型 ID 序列化精度问题、竞赛生命周期状态校验（未发布/已发布/已结束）以及题目关联逻辑。实现了从基础信息保存到题目动态添加的全流程管理，确保数据一致性与业务规则约束。

王者发布于 2026/3/21更新于 2026/4/231 浏览

在线 OJ 系统竞赛管理模块开发实战 (Java-Spring)

数据模型设计

竞赛管理的核心在于状态流转与题目关联。我们设计了 tb_exam 存储竞赛基础信息，tb_exam_question 维护竞赛与题目的多对多关系。

create table tb_exam (
    exam_id bigint unsigned not null comment '竞赛 id（主键）',
    title varchar(50) not null comment '竞赛标题',
    start_time datetime not null comment '竞赛开始时间',
    end_time datetime not null comment '竞赛结束时间',
    status tinyint not null default '0' comment '是否发布 0：未发布 1：已发布',
    create_by bigint unsigned not null comment '创建人',
    create_time datetime not null comment '创建时间',
    update_by bigint unsigned comment '更新人',
    update_time datetime comment '更新时间',
    primary key(exam_id)
);

create table tb_exam_question (
    exam_question_id bigint unsigned not null comment '竞赛题目关系 id（主键）',
    question_id bigint unsigned not null comment '题目 id（主键）',
    exam_id bigint unsigned not null comment '竞赛 id（主键）',
    question_order int not null comment '题目顺序',
    create_by bigint unsigned not null comment '创建人',
    create_time datetime  comment ,
    update_by  unsigned comment ,
    update_time datetime comment ,
    (exam_question_id)
);

@RestController
@RequestMapping("/exam")
public class ExamController extends BaseController {
    @Autowired
    private IExamService examService;

    // 获取竞赛列表
    @GetMapping("/list")
    public TableDataInfo list(ExamQueryDTO examQueryDTO) {
        return getDataTable(examService.list(examQueryDTO));
    }
}

@Getter
@Setter
@JsonInclude(JsonInclude.Include.NON_NULL)
public class ExamVO {
    @JsonSerialize(using = ToStringSerializer.class)
    private Long examId;
    private String title;
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime startTime;
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime endTime;
    private Integer status;
    private String createName; // 通过联表查询获取创建人昵称
    private LocalDateTime createTime;
}

<mapper namespace="com.bite.system.mapper.exam.ExamMapper">
    <select resultType="com.bite.system.model.exam.vo.ExamVO">
        SELECT te.exam_id, te.title, te.start_time, te.end_time, 
               te.create_time, ts.nick_name as create_name, te.status 
        FROM tb_exam te 
        LEFT JOIN tb_sys_user ts ON te.create_by = ts.user_id
        <where>
            <if test="title !=null and title !=''">
                AND te.title LIKE CONCAT('%',#{title},'%')
            </if>
            <if test="startTime != null and startTime != ''">
                AND te.start_time >= #{startTime}
            </if>
            <if test="endTime != null and endTime != ''">
                AND te.end_time &lt;= #{endTime}
            </if>
        </where>
        ORDER BY te.create_time DESC
    </select>
</mapper>

<template>
  <el-form inline="true">
    <el-form-item label="竞赛名称">
      <el-input v-model="params.title" placeholder="请输入竞赛名称" />
    </el-form-item>
    <el-form-item label="创建日期">
      <el-date-picker 
        v-model="datetimeRange" 
        type="datetimerange" 
        range-separator="至" 
        start-placeholder="开始日期" 
        end-placeholder="结束日期" 
      />
    </el-form-item>
    <el-form-item>
      <el-button @click="onSearch" plain>搜索</el-button>
      <el-button @click="onReset" plain type="info">重置</el-button>
      <el-button type="primary" :icon="Plus" plain @click="onAddExam">添加竞赛</el-button>
    </el-form-item>
  </el-form>
  <!-- 表格展示略 -->
</template>

<script setup>
// 时间处理逻辑
async function getExamList() {
  if (datetimeRange.value[0] instanceof Date) {
    params.startTime = datetimeRange.value[0].toISOString();
  }
  if (datetimeRange.value[1] instanceof Date) {
    params.endTime = datetimeRange.value[1].toISOString();
  }
  const result = await getExamListService(params);
  examList.value = result.rows;
  total.value = result.total;
}
</script>

@Override
public String add(ExamAddDTO examAddDTO) {
    checkExamSaveParams(examAddDTO, null);
    Exam exam = new Exam();
    BeanUtil.copyProperties(examAddDTO, exam);
    examMapper.insert(exam);
    return exam.getExamId().toString();
}

private void checkExamSaveParams(ExamAddDTO examSaveDTO, Long examId) {
    // 校验标题重复
    List<Exam> examList = examMapper.selectList(
        new LambdaQueryWrapper<Exam>()
            .eq(Exam::getTitle, examSaveDTO.getTitle())
            .ne(examId != null, Exam::getExamId, examId)
    );
    if (CollectionUtil.isNotEmpty(examList)) {
        throw new ServiceException(ResultCode.FAILED_ALREADY_EXISTS);
    }
    // 校验时间逻辑
    if (examSaveDTO.getStartTime().isBefore(LocalDateTime.now())) {
        throw new ServiceException(ResultCode.EXAM_START_TIME_BEFORE_CURRENT_TIME);
    }
    if (examSaveDTO.getStartTime().isAfter(examSaveDTO.getEndTime())) {
        throw new ServiceException(ResultCode.EXAM_START_TIME_AFTER_END_TIME);
    }
}

@Override
public boolean questionAdd(ExamQuestAddDTO examQuestAddDTO) {
    Exam exam = getExam(examQuestAddDTO.getExamId());
    checkExam(exam); // 检查竞赛是否存在及状态
    Set<Long> questionIdSet = examQuestAddDTO.getQuestionIdSet();
    if (CollectionUtil.isEmpty(questionIdSet)) return true;

    // 批量校验题目存在性
    List<Question> questionList = questionMapper.selectBatchIds(questionIdSet);
    if (CollectionUtil.isEmpty(questionList) || questionList.size() < questionIdSet.size()) {
        throw new ServiceException(ResultCode.EXAM_QUESTION_NOT_EXISTS);
    }
    return saveExamQuestion(exam, questionIdSet);
}

@Override
public ExamDetailVO detail(Long examId) {
    ExamDetailVO examDetailVO = new ExamDetailVO();
    Exam exam = getExam(examId);
    BeanUtil.copyProperties(exam, examDetailVO);

    // 按顺序获取题目 ID
    List<ExamQuestion> examQuestionList = examQuestionMapper.selectList(
        new LambdaQueryWrapper<ExamQuestion>()
            .select(ExamQuestion::getQuestionId)
            .eq(ExamQuestion::getExamId, examId)
            .orderByAsc(ExamQuestion::getQuestionOrder)
    );
    
    if (CollectionUtil.isEmpty(examQuestionList)) return examDetailVO;

    List<Long> questionIdList = examQuestionList.stream()
        .map(ExamQuestion::getQuestionId).toList();
    
    List<Question> questionList = questionMapper.selectList(
        new LambdaQueryWrapper<Question>()
            .select(Question::getQuestionId, Question::getTitle, Question::getDifficulty)
            .in(Question::getQuestionId, questionIdList)
    );
    
    examDetailVO.setExamQuestionList(BeanUtil.copyToList(questionList, QuestionVO.class));
    return examDetailVO;
}

@Override
public int delete(Long examId) {
    Exam exam = getExam(examId);
    // 已发布或已结束不可删除
    if (Contants.TRUE.equals(exam.getStatus())) {
        throw new ServiceException(ResultCode.EXAM_IS_PUBLISH);
    }
    checkExam(exam);
    // 级联删除关联题目
    examQuestionMapper.delete(new LambdaQueryWrapper<ExamQuestion>().eq(ExamQuestion::getExamId, examId));
    return examMapper.deleteById(exam);
}

<!-- 题库查询排除已选 ID -->
<if test="excludeIdSet !=null and !excludeIdSet.isEmpty()">
    <foreach collection="excludeIdSet" open=" AND tq.question_id NOT IN( " close=" ) " item="id" separator=",">
        #{id}
    </foreach>
</if>

@Override
public int publish(Long examId) {
    Exam exam = getExam(examId);
    if (exam.getEndTime().isBefore(LocalDateTime.now())) {
        throw new ServiceException(ResultCode.EXAM_IS_FINISH);
    }
    Long count = examQuestionMapper.selectCount(
        new LambdaQueryWrapper<ExamQuestion>().eq(ExamQuestion::getExamId, examId)
    );
    if (count == null || count <= 0) {
        throw new ServiceException(ResultCode.EXAM_NOT_HAS_QUESTION);
    }
    exam.setStatus(Contants.TRUE);
    return examMapper.updateById(exam);
}