Java全栈项目 - 学生竞赛管理平台

项目介绍

学生竞赛管理平台是一个基于Spring Boot + Vue.js的全栈Web应用，旨在为高校提供一个完整的竞赛管理解决方案。该平台可以帮助学校管理各类学科竞赛信息，方便学生报名参赛，并为教师提供竞赛指导和成绩管理功能。

技术栈

后端

Spring Boot 2.7
Spring Security
MyBatis-Plus
MySQL 8.0
Redis
JWT认证

前端

Vue 3
Element Plus
Axios
Vuex
Vue Router

核心功能

1. 竞赛管理

竞赛信息发布
竞赛分类管理
竞赛时间线管理
参赛名额控制

2. 学生功能

竞赛信息浏览
在线报名
组队功能
成绩查询
获奖证书下载

3. 教师功能

竞赛指导
成绩录入
学生管理
数据统计

4. 系统管理

用户权限管理
系统配置
日志管理
数据备份

数据库设计

主要数据表

-- 竞赛信息表
CREATE TABLE competition (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(100) NOT NULL,
    description TEXT,
    start_time DATETIME,
    end_time DATETIME,
    status TINYINT,
    created_time DATETIME
);

-- 参赛记录表
CREATE TABLE participation (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    student_id BIGINT,
    competition_id BIGINT,
    team_id BIGINT,
    status TINYINT,
    score DECIMAL(5,2),
    created_time DATETIME
);

核心代码示例

后端接口示例

@RestController
@RequestMapping("/api/competition")
public class CompetitionController {
    
    @Autowired
    private CompetitionService competitionService;
    
    @GetMapping("/list")
    public Result getCompetitionList(CompetitionQuery query) {
        Page<Competition> page = competitionService.queryByPage(query);
        return Result.success(page);
    }
    
    @PostMapping("/register")
    public Result register(@RequestBody RegistrationDTO dto) {
        competitionService.registerCompetition(dto);
        return Result.success();
    }
}

前端代码示例

<template>
  <div class="competition-list">
    <el-table :data="competitions" stripe>
      <el-table-column prop="name" label="竞赛名称" />
      <el-table-column prop="startTime" label="开始时间" />
      <el-table-column prop="status" label="状态">
        <template #default="scope">
          <el-tag :type="getStatusType(scope.row.status)">
            {{ getStatusText(scope.row.status) }}
          </el-tag>
        </template>
      </el-table-column>
      <el-table-column label="操作">
        <template #default="scope">
          <el-button @click="handleRegister(scope.row)">报名</el-button>
        </template>
      </el-table-column>
    </el-table>
  </div>
</template>

项目亮点

分布式Session管理
- 使用Redis存储session信息
- 支持水平扩展
- 提高系统可用性
实时通知功能
- 基于WebSocket实现
- 竞赛状态实时推送
- 重要通知即时提醒
高性能查询优化
- 合理使用缓存
- SQL优化
- 索引设计
完善的权限控制
- 基于RBAC模型
- 细粒度权限管理
- 动态权限配置

项目部署

环境要求

JDK 1.8+
Maven 3.6+
Node.js 14+
MySQL 8.0
Redis 6.0

部署步骤

后端打包：mvn clean package
前端打包：npm run build
配置Nginx反向代理
使用Docker容器化部署

项目总结

通过本项目的开发，不仅实现了一个功能完善的竞赛管理平台，还在以下方面得到了提升：

全栈开发能力
分布式系统设计经验
性能优化实践
项目管理能力

后续优化方向

引入微服务架构
添加大数据分析功能
优化移动端适配
增加AI辅助功能

学生竞赛管理平台功能详解

一、竞赛管理模块

1. 竞赛信息发布

功能描述

支持富文本编辑器发布竞赛详情
可上传竞赛相关附件
支持定时发布
竞赛信息版本控制

核心代码

@Service
public class CompetitionServiceImpl implements CompetitionService {
    
    @Autowired
    private CompetitionMapper competitionMapper;
    
    @Override
    @Transactional
    public void publishCompetition(CompetitionDTO dto) {
        // 1. 基础信息保存
        Competition competition = new Competition();
        BeanUtils.copyProperties(dto, competition);
        
        // 2. 处理富文本内容
        String content = processRichText(dto.getContent());
        competition.setContent(content);
        
        // 3. 处理附件
        List<String> attachments = uploadAttachments(dto.getAttachments());
        competition.setAttachments(JSON.toJSONString(attachments));
        
        // 4. 设置发布状态
        if (dto.getPublishTime().after(new Date())) {
            competition.setStatus(CompetitionStatus.SCHEDULED.getCode());
        } else {
            competition.setStatus(CompetitionStatus.PUBLISHED.getCode());
        }
        
        competitionMapper.insert(competition);
    }
}

2. 竞赛分类管理

功能描述

多级分类体系
分类标签管理
分类统计分析
动态分类配置

数据结构

-- 竞赛分类表
CREATE TABLE competition_category (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    parent_id BIGINT COMMENT '父分类ID',
    name VARCHAR(50) NOT NULL COMMENT '分类名称',
    code VARCHAR(50) COMMENT '分类编码',
    level INT COMMENT '层级',
    sort INT COMMENT '排序号',
    status TINYINT COMMENT '状态',
    created_time DATETIME,
    updated_time DATETIME,
    INDEX idx_parent_id (parent_id)
);

-- 竞赛分类关联表
CREATE TABLE competition_category_rel (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    competition_id BIGINT,
    category_id BIGINT,
    created_time DATETIME,
    INDEX idx_competition_id (competition_id),
    INDEX idx_category_id (category_id)
);

3. 竞赛时间线管理

功能描述

竞赛阶段配置
自动状态流转
提醒通知
进度追踪

核心代码

@Component
public class CompetitionTimelineManager {
    
    @Autowired
    private CompetitionService competitionService;
    
    @Scheduled(cron = "0 0/5 * * * ?")
    public void checkCompetitionStatus() {
        List<Competition> competitions = competitionService.getActiveCompetitions();
        
        for (Competition competition : competitions) {
            CompetitionTimeline timeline = competition.getTimeline();
            Date now = new Date();
            
            // 检查并更新竞赛阶段
            if (now.after(timeline.getRegistrationEndTime())) {
                competition.setPhase(CompetitionPhase.COMPETITION);
                // 发送比赛开始通知
                notifyCompetitionStart(competition);
            }
            
            if (now.after(timeline.getCompetitionEndTime())) {
                competition.setPhase(CompetitionPhase.EVALUATION);
                // 发送比赛结束通知
                notifyCompetitionEnd(competition);
            }
            
            competitionService.updateCompetition(competition);
        }
    }
}

4. 参赛名额控制

功能描述

总名额限制
分组名额限制
实时名额统计
候补名单管理

核心实现

@Service
public class RegistrationService {
    
    @Autowired
    private RedisTemplate redisTemplate;
    
    private static final String QUOTA_KEY = "competition:quota:";
    
    @Transactional
    public boolean register(RegistrationDTO dto) {
        String quotaKey = QUOTA_KEY + dto.getCompetitionId();
        
        // 使用Redis进行原子性的名额检查和扣减
        Long remainQuota = redisTemplate.opsForValue().decrement(quotaKey);
        
        if (remainQuota < 0) {
            // 恢复名额
            redisTemplate.opsForValue().increment(quotaKey);
            
            // 加入候补名单
            addToWaitingList(dto);
            return false;
        }
        
        // 创建报名记录
        createRegistration(dto);
        return true;
    }
}

二、学生功能模块

1. 竞赛信息浏览

功能描述

分类筛选
高级搜索
个性化推荐
收藏关注

前端实现

<template>
  <div class="competition-browser">
    <!-- 搜索过滤区 -->
    <el-form :model="searchForm" inline>
      <el-form-item label="竞赛类型">
        <el-cascader
          v-model="searchForm.categoryIds"
          :options="categoryOptions"
          :props="{ checkStrictly: true }"
        />
      </el-form-item>
      <el-form-item label="状态">
        <el-select v-model="searchForm.status">
          <el-option
            v-for="item in statusOptions"
            :key="item.value"
            :label="item.label"
            :value="item.value"
          />
        </el-select>
      </el-form-item>
    </el-form>
    
    <!-- 竞赛列表 -->
    <el-row :gutter="20">
      <el-col :span="6" v-for="item in competitions" :key="item.id">
        <competition-card
          :competition="item"
          @click="handleCompetitionClick"
          @collect="handleCollect"
        />
      </el-col>
    </el-row>
  </div>
</template>

2. 在线报名

功能描述

表单验证
材料上传
支付功能
报名进度查询

核心代码

@RestController
@RequestMapping("/api/registration")
public class RegistrationController {
    
    @Autowired
    private RegistrationService registrationService;
    
    @PostMapping("/submit")
    public Result submit(@Valid @RequestBody RegistrationForm form) {
        // 1. 检查报名资格
        checkEligibility(form);
        
        // 2. 处理报名材料
        List<String> materials = uploadMaterials(form.getMaterials());
        
        // 3. 创建支付订单
        PaymentOrder order = createPaymentOrder(form);
        
        // 4. 提交报名信息
        RegistrationDTO dto = buildRegistrationDTO(form, materials, order);
        registrationService.register(dto);
        
        return Result.success(order);
    }
    
    @GetMapping("/progress/{registrationId}")
    public Result getProgress(@PathVariable Long registrationId) {
        RegistrationProgress progress = registrationService.getProgress(registrationId);
        return Result.success(progress);
    }
}

3. 组队功能

功能描述

创建/加入团队
队长管理
团队信息维护
队内交流

数据结构

-- 团队表
CREATE TABLE team (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    competition_id BIGINT,
    name VARCHAR(100),
    leader_id BIGINT,
    max_members INT,
    current_members INT,
    status TINYINT,
    created_time DATETIME,
    INDEX idx_competition_id (competition_id)
);

-- 团队成员表
CREATE TABLE team_member (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    team_id BIGINT,
    user_id BIGINT,
    role TINYINT COMMENT '1:队长 2:成员',
    join_time DATETIME,
    status TINYINT,
    INDEX idx_team_id (team_id),
    INDEX idx_user_id (user_id)
);

4. 成绩查询

功能描述

实时成绩查询
成绩分析
排名查看
历史成绩统计

核心实现

@Service
public class ScoreService {
    
    @Autowired
    private ScoreMapper scoreMapper;
    
    public ScoreVO queryScore(Long userId, Long competitionId) {
        // 1. 获取基础成绩信息
        Score score = scoreMapper.selectByUserAndCompetition(userId, competitionId);
        
        // 2. 计算排名
        int rank = calculateRank(score);
        
        // 3. 获取成绩分析
        ScoreAnalysis analysis = analyzeScore(score);
        
        // 4. 构建返回对象
        return ScoreVO.builder()
                .score(score)
                .rank(rank)
                .analysis(analysis)
                .build();
    }
    
    private ScoreAnalysis analyzeScore(Score score) {
        // 成绩分析逻辑
        return ScoreAnalysis.builder()
                .averageScore(calculateAverageScore())
                .distribution(calculateDistribution())
                .trend(calculateTrend())
                .build();
    }
}

5. 获奖证书下载

功能描述

证书模板管理
证书生成
防伪验证
批量下载

核心代码

@Service
public class CertificateService {
    
    @Autowired
    private CertificateTemplate certificateTemplate;
    
    public String generateCertificate(CertificateDTO dto) {
        // 1. 加载证书模板
        Template template = certificateTemplate.getTemplate(dto.getTemplateId());
        
        // 2. 生成证书编号
        String certificateNo = generateCertificateNo(dto);
        
        // 3. 填充证书内容
        Map<String, Object> params = new HashMap<>();
        params.put("userName", dto.getUserName());
        params.put("competitionName", dto.getCompetitionName());
        params.put("award", dto.getAward());
        params.put("date", new Date());
        params.put("certificateNo", certificateNo);
        
        // 4. 生成证书PDF
        String pdfPath = template.generate(params);
        
        // 5. 保存证书记录
        saveCertificateRecord(dto, certificateNo, pdfPath);
        
        return pdfPath;
    }
    
    // 证书防伪验证
    public boolean verifyCertificate(String certificateNo) {
        // 验证证书真实性
        return certificateMapper.verify(certificateNo) != null;
    }
}

学生竞赛管理平台功能详解（二）

三、教师功能模块

1. 竞赛指导

功能描述

指导团队管理
在线辅导
资料共享
进度跟踪

数据结构

-- 指导关系表
CREATE TABLE teacher_guidance (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    teacher_id BIGINT,
    team_id BIGINT,
    competition_id BIGINT,
    status TINYINT,
    created_time DATETIME,
    INDEX idx_teacher_id (teacher_id),
    INDEX idx_team_id (team_id)
);

-- 辅导记录表
CREATE TABLE guidance_record (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    guidance_id BIGINT,
    type TINYINT COMMENT '1:在线辅导 2:资料分享 3:进度检查',
    content TEXT,
    attachments TEXT,
    created_time DATETIME,
    INDEX idx_guidance_id (guidance_id)
);

核心实现

@Service
public class GuidanceService {
    
    @Autowired
    private WebSocketServer webSocketServer;
    
    // 创建在线辅导会话
    public String createGuidanceSession(GuidanceSessionDTO dto) {
        // 生成会话ID
        String sessionId = generateSessionId();
        
        // 创建会话记录
        GuidanceSession session = GuidanceSession.builder()
            .sessionId(sessionId)
            .teacherId(dto.getTeacherId())
            .teamId(dto.getTeamId())
            .startTime(new Date())
            .status(SessionStatus.ACTIVE)
            .build();
            
        // 保存会话信息
        sessionMapper.insert(session);
        
        // 通知相关学生
        notifyTeamMembers(dto.getTeamId(), sessionId);
        
        return sessionId;
    }
    
    // 分享资料
    @Transactional
    public void shareMaterials(MaterialShareDTO dto) {
        // 上传资料
        List<String> fileUrls = fileService.uploadFiles(dto.getFiles());
        
        // 创建分享记录
        GuidanceRecord record = GuidanceRecord.builder()
            .guidanceId(dto.getGuidanceId())
            .type(GuidanceType.MATERIAL_SHARE)
            .content(dto.getDescription())
            .attachments(JSON.toJSONString(fileUrls))
            .build();
            
        recordMapper.insert(record);
        
        // 发送通知
        sendNotification(dto.getTeamId(), "新的学习资料已分享");
    }
}

2. 成绩录入

功能描述

批量成绩导入
成绩审核
成绩修正
评分标准管理

核心代码

@Service
public class ScoreManagementService {
    
    @Autowired
    private ScoreMapper scoreMapper;
    
    // 批量导入成绩
    @Transactional
    public ImportResult importScores(MultipartFile file) {
        ImportResult result = new ImportResult();
        
        try {
            // 解析Excel文件
            List<ScoreImportDTO> scores = parseExcel(file);
            
            // 数据验证
            List<ScoreImportDTO> validScores = validateScores(scores);
            
            // 批量保存
            for (ScoreImportDTO score : validScores) {
                try {
                    saveScore(score);
                    result.addSuccess();
                } catch (Exception e) {
                    result.addError(score, e.getMessage());
                }
            }
        } catch (Exception e) {
            result.setStatus(ImportStatus.FAILED);
            result.setMessage(e.getMessage());
        }
        
        return result;
    }
    
    // 成绩审核
    @Transactional
    public void reviewScore(ScoreReviewDTO dto) {
        Score score = scoreMapper.selectById(dto.getScoreId());
        
        // 权限检查
        checkReviewPermission(dto.getReviewerId(), score);
        
        // 更新成绩状态
        if (dto.isApproved()) {
            score.setStatus(ScoreStatus.APPROVED);
            score.setApprovedBy(dto.getReviewerId());
            score.setApprovedTime(new Date());
        } else {
            score.setStatus(ScoreStatus.REJECTED);
            score.setRejectReason(dto.getReason());
        }
        
        scoreMapper.updateById(score);
        
        // 发送通知
        notifyScoreResult(score);
    }
}

3. 学生管理

功能描述

学生信息维护
分组管理
考勤记录
表现评价

数据结构

-- 学生分组表
CREATE TABLE student_group (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    teacher_id BIGINT,
    name VARCHAR(50),
    description TEXT,
    created_time DATETIME,
    INDEX idx_teacher_id (teacher_id)
);

-- 考勤记录表
CREATE TABLE attendance_record (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    student_id BIGINT,
    group_id BIGINT,
    type TINYINT COMMENT '1:正常 2:迟到 3:早退 4:缺勤',
    record_time DATETIME,
    remark VARCHAR(200),
    INDEX idx_student_id (student_id),
    INDEX idx_group_id (group_id)
);

核心实现

@Service
public class StudentManagementService {
    
    // 学生分组管理
    public void manageGroup(GroupManagementDTO dto) {
        switch (dto.getOperation()) {
            case CREATE:
                createGroup(dto);
                break;
            case UPDATE:
                updateGroup(dto);
                break;
            case DELETE:
                deleteGroup(dto.getGroupId());
                break;
            case ADD_STUDENTS:
                addStudentsToGroup(dto.getGroupId(), dto.getStudentIds());
                break;
            case REMOVE_STUDENTS:
                removeStudentsFromGroup(dto.getGroupId(), dto.getStudentIds());
                break;
        }
    }
    
    // 记录考勤
    public void recordAttendance(AttendanceDTO dto) {
        // 验证考勤时间
        validateAttendanceTime(dto);
        
        // 创建考勤记录
        AttendanceRecord record = AttendanceRecord.builder()
            .studentId(dto.getStudentId())
            .groupId(dto.getGroupId())
            .type(dto.getType())
            .recordTime(dto.getRecordTime())
            .remark(dto.getRemark())
            .build();
            
        attendanceMapper.insert(record);
        
        // 更新统计数据
        updateAttendanceStatistics(dto.getStudentId());
    }
}

4. 数据统计

功能描述

竞赛数据分析
成绩统计报表
参与度分析
数据可视化

核心代码

@Service
public class StatisticsService {
    
    @Autowired
    private CompetitionMapper competitionMapper;
    
    // 生成竞赛统计报表
    public CompetitionStatistics generateStatistics(StatisticsQuery query) {
        return CompetitionStatistics.builder()
            .totalParticipants(countParticipants(query))
            .averageScore(calculateAverageScore(query))
            .participationRate(calculateParticipationRate(query))
            .awardDistribution(getAwardDistribution(query))
            .scoreDistribution(getScoreDistribution(query))
            .departmentAnalysis(analyzeDepartmentPerformance(query))
            .trendAnalysis(analyzeTrend(query))
            .build();
    }
    
    // 导出Excel报表
    public String exportReport(ReportQuery query) {
        // 获取统计数据
        CompetitionStatistics statistics = generateStatistics(query);
        
        // 创建Excel工作簿
        Workbook workbook = new XSSFWorkbook();
        
        // 添加统计表格
        addStatisticsSheet(workbook, statistics);
        
        // 添加图表
        addCharts(workbook, statistics);
        
        // 保存文件
        String filePath = saveExcelFile(workbook);
        
        return filePath;
    }
}

四、系统管理模块

1. 用户权限管理

功能描述

用户角色管理
权限分配
访问控制
操作审计

数据结构

-- 角色表
CREATE TABLE role (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(50),
    code VARCHAR(50),
    description TEXT,
    status TINYINT,
    created_time DATETIME
);

-- 权限表
CREATE TABLE permission (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(50),
    code VARCHAR(50),
    type TINYINT,
    parent_id BIGINT,
    path VARCHAR(200),
    created_time DATETIME
);

-- 角色权限关联表
CREATE TABLE role_permission (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    role_id BIGINT,
    permission_id BIGINT,
    created_time DATETIME,
    INDEX idx_role_id (role_id),
    INDEX idx_permission_id (permission_id)
);

核心实现

@Service
public class AuthorizationService {
    
    @Autowired
    private RedisTemplate redisTemplate;
    
    // 权限检查
    public boolean hasPermission(Long userId, String permissionCode) {
        // 从缓存获取用户权限
        Set<String> permissions = getUserPermissions(userId);
        
        // 检查权限
        return permissions.contains(permissionCode);
    }
    
    // 分配角色
    @Transactional
    public void assignRoles(RoleAssignmentDTO dto) {
        // 删除原有角色
        userRoleMapper.deleteByUserId(dto.getUserId());
        
        // 分配新角色
        for (Long roleId : dto.getRoleIds()) {
            UserRole userRole = new UserRole();
            userRole.setUserId(dto.getUserId());
            userRole.setRoleId(roleId);
            userRoleMapper.insert(userRole);
        }
        
        // 清除缓存
        clearUserPermissionCache(dto.getUserId());
    }
}

2. 系统配置

功能描述

参数配置
字典管理
菜单配置
系统公告

核心代码

@Service
public class SystemConfigService {
    
    @Autowired
    private RedisTemplate redisTemplate;
    
    private static final String CONFIG_CACHE_KEY = "system:config:";
    
    // 更新系统配置
    @Transactional
    public void updateConfig(ConfigUpdateDTO dto) {
        // 保存配置
        SystemConfig config = SystemConfig.builder()
            .code(dto.getCode())
            .value(dto.getValue())
            .description(dto.getDescription())
            .updateTime(new Date())
            .build();
            
        configMapper.updateById(config);
        
        // 更新缓存
        redisTemplate.opsForValue().set(
            CONFIG_CACHE_KEY + config.getCode(), 
            config.getValue()
        );
        
        // 发布配置更新事件
        publishConfigUpdateEvent(config);
    }
    
    // 获取配置值
    public String getConfigValue(String code) {
        // 先从缓存获取
        String value = (String) redisTemplate.opsForValue()
            .get(CONFIG_CACHE_KEY + code);
            
        if (value == null) {
            // 从数据库获取
            SystemConfig config = configMapper.selectByCode(code);
            if (config != null) {
                value = config.getValue();
                // 放入缓存
                redisTemplate.opsForValue().set(
                    CONFIG_CACHE_KEY + code, 
                    value
                );
            }
        }
        
        return value;
    }
}

3. 日志管理

功能描述

操作日志
登录日志
异常日志
日志分析

核心实现

@Aspect
@Component
public class LogAspect {
    
    @Autowired
    private LogService logService;
    
    // 记录操作日志
    @Around("@annotation(operationLog)")
    public Object logOperation(ProceedingJoinPoint joinPoint, 
                             OperationLog operationLog) throws Throwable {
        // 开始时间
        long startTime = System.currentTimeMillis();
        
        // 获取用户信息
        UserDetails user = SecurityUtils.getCurrentUser();
        
        // 记录请求信息
        OperationLogDTO logDTO = OperationLogDTO.builder()
            .userId(user.getId())
            .module(operationLog.module())
            .operation(operationLog.operation())
            .method(joinPoint.getSignature().getName())
            .params(JSON.toJSONString(joinPoint.getArgs()))
            .startTime(new Date(startTime))
            .build();
            
        try {
            // 执行目标方法
            Object result = joinPoint.proceed();
            
            // 记录响应结果
            logDTO.setSuccess(true);
            logDTO.setResponse(JSON.toJSONString(result));
            
            return result;
        } catch (Exception e) {
            // 记录异常信息
            logDTO.setSuccess(false);
            logDTO.setErrorMsg(e.getMessage());
            throw e;
        } finally {
            // 计算执行时间
            logDTO.setDuration(System.currentTimeMillis() - startTime);
            
            // 异步保存日志
            logService.asyncSaveLog(logDTO);
        }
    }
}

4. 数据备份

功能描述

自动备份
手动备份
备份恢复
备份策略管理

核心代码

@Service
public class BackupService {
    
    @Autowired
    private DataSourceProperties dataSourceProperties;
    
    // 执行备份
    public String backup(BackupDTO dto) {
        // 生成备份文件名
        String fileName = generateBackupFileName();
        
        // 构建备份命令
        String command = String.format(
            "mysqldump -h%s -P%s -u%s -p%s %s > %s",
            dataSourceProperties.getHost(),
            dataSourceProperties.getPort(),
            dataSourceProperties.getUsername(),
            dataSourceProperties.getPassword(),
            dataSourceProperties.getDatabase(),
            fileName
        );
        
        try {
            // 执行备份命令
            Process process = Runtime.getRuntime().exec(command);
            int exitCode = process.waitFor();
            
            if (exitCode == 0) {
                // 备份成功，上传到存储服务
                String url = uploadBackupFile(fileName);
                
                // 记录备份信息
                saveBackupRecord(dto, url);
                
                return url;
            } else {
                throw new BackupException("数据库备份失败");
            }
        } catch (Exception e) {
            throw new BackupException("执行备份出错", e);
        }
    }
    
    // 恢复数据
    @Transactional
    public void restore(String backupUrl) {
        // 下载备份文件
        String fileName = downloadBackupFile(backupUrl);
        
        // 构建恢复命令
        String command = String.format(
            "mysql -h%s -P%s -u%s -p%s %s < %s",
            dataSourceProperties.getHost(),
            dataSourceProperties.getPort(),
            dataSourceProperties.getUsername(),
            dataSourceProperties.getPassword(),
            dataSourceProperties.getDatabase(),
            fileName
        );
        
        try {
            // 执行恢复命令
            Process process = Runtime.getRuntime().exec(command);
            int exitCode = process.waitFor();
            
            if (exitCode != 0) {
                throw new RestoreException("数据恢复失败");
            }
            
            // 记录恢复操作
            saveRestoreRecord(backupUrl);
        } catch (Exception e) {
            throw new RestoreException("执行恢复出错", e);
        }
    }
}