基于 Spring Boot 的在线 OJ 系统竞赛管理模块实现 | 极客日志

Javajava算法

基于 Spring Boot 的在线 OJ 系统竞赛管理模块实现

在线 OJ 系统竞赛管理模块涵盖竞赛全生命周期维护，包括列表查询、创建、编辑、发布与撤销。数据库设计采用主从表结构存储竞赛与题目关系，支持动态题目组合。后端基于 Spring Boot 与 MyBatis Plus 构建，重点处理长整型 ID 序列化精度问题及并发状态校验。前端使用 Vue 组件化开发，实现日期范围选择与题目多选联动。核心逻辑确保未发布竞赛可自由调整，已发布或进行中竞赛限制修改，保障赛事数据一致性。

ApiHolic发布于 2026/3/29更新于 2026/4/304 浏览

基于 Spring Boot 的在线 OJ 系统竞赛管理模块实现

数据库设计

竞赛管理涉及竞赛基本信息与题目关联，采用主从表结构存储。

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 not null 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));
    }
}

<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>

@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;
    // ... 其他字段
}

<template>
  <el-table :data="examList">
    <el-table-column prop="title" label="竞赛标题" />
    <el-table-column prop="startTime" label="竞赛开始时间" />
    <el-table-column label="是否开赛">
      <template #default="{ row }">
        <el-tag v-if="!isNotStartExam(row)" type="warning">已开赛</el-tag>
        <el-tag v-else type="info">未开赛</el-tag>
      </template>
    </el-table-column>
    <!-- 操作列 -->
  </el-table>
</template>
<script setup>
function isNotStartExam(exam) {
  const now = new Date();
  return new Date(exam.startTime) > now;
}
</script>

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 ExamDetailVO detail(Long examId) {
    Exam exam = getExam(examId);
    ExamDetailVO vo = BeanUtil.copyProperties(exam, ExamDetailVO.class);
    
    // 获取题目 ID 列表
    List<Long> questionIds = examQuestionMapper.selectList(
        new LambdaQueryWrapper<ExamQuestion>()
            .select(ExamQuestion::getQuestionId)
            .eq(ExamQuestion::getExamId, examId)
            .orderByAsc(ExamQuestion::getQuestionOrder)
    ).stream()
    .map(ExamQuestion::getQuestionId)
    .toList();
    
    // 批量查询题目信息
    List<QuestionVO> questionVOList = questionMapper.selectBatchIds(questionIds)
        .stream()
        .map(q -> BeanUtil.copyProperties(q, QuestionVO.class))
        .collect(Collectors.toList());
    
    vo.setExamQuestionList(questionVOList);
    return vo;
}

@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);
}