第51集MinIO断点续传功能分片上传与断点续传实战

/**
 * MinIO配置类
 */
@Configuration
public class MinIOConfig {
    
    @Value("${minio.endpoint}")
    private String endpoint;
    
    @Value("${minio.access-key}")
    private String accessKey;
    
    @Value("${minio.secret-key}")
    private String secretKey;
    
    @Value("${minio.bucket-name}")
    private String bucketName;
    
    @Value("${minio.chunk-size}")
    private long chunkSize;
    
    @Value("${minio.max-file-size}")
    private long maxFileSize;
    
    /**
     * MinIO客户端
     */
    @Bean
    public MinioClient minioClient() {
        return MinioClient.builder()
            .endpoint(endpoint)
            .credentials(accessKey, secretKey)
            .build();
    }
    
    /**
     * MinIO配置属性
     */
    @Bean
    public MinIOProperties minioProperties() {
        return MinIOProperties.builder()
            .endpoint(endpoint)
            .accessKey(accessKey)
            .secretKey(secretKey)
            .bucketName(bucketName)
            .chunkSize(chunkSize)
            .maxFileSize(maxFileSize)
            .build();
    }
    
    /**
     * 初始化MinIO
     */
    @PostConstruct
    public void initMinIO() {
        try {
            MinioClient client = minioClient();
            
            // 检查存储桶是否存在
            boolean bucketExists = client.bucketExists(BucketExistsArgs.builder()
                .bucket(bucketName)
                .build());
            
            if (!bucketExists) {
                // 创建存储桶
                client.makeBucket(MakeBucketArgs.builder()
                    .bucket(bucketName)
                    .build());
                
                log.info("创建MinIO存储桶成功: {}", bucketName);
            } else {
                log.info("MinIO存储桶已存在: {}", bucketName);
            }
            
        } catch (Exception e) {
            log.error("初始化MinIO失败", e);
            throw new RuntimeException("初始化MinIO失败", e);
        }
    }
}

/**
 * MinIO配置属性
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class MinIOProperties {
    private String endpoint;
    private String accessKey;
    private String secretKey;
    private String bucketName;
    private long chunkSize;
    private long maxFileSize;
}

/**
 * 分片上传服务
 */
@Service
public class ChunkUploadService {
    
    @Autowired
    private MinioClient minioClient;
    
    @Autowired
    private MinIOProperties minioProperties;
    
    @Autowired
    private UploadProgressService progressService;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    /**
     * 初始化分片上传
     * @param fileName 文件名
     * @param fileSize 文件大小
     * @param chunkCount 分片数量
     * @return 上传ID
     */
    public String initChunkUpload(String fileName, long fileSize, int chunkCount) {
        try {
            // 1. 验证文件大小
            if (fileSize > minioProperties.getMaxFileSize()) {
                throw new BusinessException("文件大小超过限制");
            }
            
            // 2. 生成上传ID
            String uploadId = generateUploadId(fileName);
            
            // 3. 创建上传记录
            ChunkUploadInfo uploadInfo = ChunkUploadInfo.builder()
                .uploadId(uploadId)
                .fileName(fileName)
                .fileSize(fileSize)
                .chunkCount(chunkCount)
                .uploadedChunks(new HashSet<>())
                .status("INITIALIZED")
                .createTime(LocalDateTime.now())
                .build();
            
            // 4. 保存到Redis
            String key = "chunk:upload:" + uploadId;
            redisTemplate.opsForValue().set(key, uploadInfo, Duration.ofHours(24));
            
            // 5. 初始化进度
            progressService.initProgress(uploadId, chunkCount);
            
            log.info("初始化分片上传成功: uploadId={}, fileName={}, chunkCount={}", 
                uploadId, fileName, chunkCount);
            
            return uploadId;
            
        } catch (Exception e) {
            log.error("初始化分片上传失败: fileName={}", fileName, e);
            throw new BusinessException("初始化分片上传失败: " + e.getMessage());
        }
    }
    
    /**
     * 上传分片
     * @param uploadId 上传ID
     * @param chunkNumber 分片编号
     * @param chunkData 分片数据
     * @return 上传结果
     */
    public ChunkUploadResult uploadChunk(String uploadId, int chunkNumber, byte[] chunkData) {
        try {
            // 1. 获取上传信息
            ChunkUploadInfo uploadInfo = getUploadInfo(uploadId);
            if (uploadInfo == null) {
                throw new BusinessException("上传信息不存在");
            }
            
            // 2. 检查分片是否已上传
            if (uploadInfo.getUploadedChunks().contains(chunkNumber)) {
                return ChunkUploadResult.success("分片已存在");
            }
            
            // 3. 上传分片到MinIO
            String objectName = uploadId + "/" + chunkNumber;
            
            minioClient.putObject(PutObjectArgs.builder()
                .bucket(minioProperties.getBucketName())
                .object(objectName)
                .stream(new ByteArrayInputStream(chunkData), chunkData.length, -1)
                .build());
            
            // 4. 更新上传信息
            uploadInfo.getUploadedChunks().add(chunkNumber);
            uploadInfo.setUpdateTime(LocalDateTime.now());
            
            String key = "chunk:upload:" + uploadId;
            redisTemplate.opsForValue().set(key, uploadInfo, Duration.ofHours(24));
            
            // 5. 更新进度
            progressService.updateProgress(uploadId, chunkNumber);
            
            // 6. 检查是否完成
            if (uploadInfo.getUploadedChunks().size() == uploadInfo.getChunkCount()) {
                // 触发分片合并
                CompletableFuture.runAsync(() -> mergeChunks(uploadId));
            }
            
            log.debug("分片上传成功: uploadId={}, chunkNumber={}", uploadId, chunkNumber);
            
            return ChunkUploadResult.success("分片上传成功");
            
        } catch (Exception e) {
            log.error("分片上传失败: uploadId={}, chunkNumber={}", uploadId, chunkNumber, e);
            return ChunkUploadResult.error("分片上传失败: " + e.getMessage());
        }
    }
    
    /**
     * 合并分片
     * @param uploadId 上传ID
     * @return 合并结果
     */
    public ChunkMergeResult mergeChunks(String uploadId) {
        try {
            // 1. 获取上传信息
            ChunkUploadInfo uploadInfo = getUploadInfo(uploadId);
            if (uploadInfo == null) {
                throw new BusinessException("上传信息不存在");
            }
            
            // 2. 检查所有分片是否已上传
            if (uploadInfo.getUploadedChunks().size() != uploadInfo.getChunkCount()) {
                throw new BusinessException("分片未完全上传");
            }
            
            // 3. 更新状态为合并中
            uploadInfo.setStatus("MERGING");
            updateUploadInfo(uploadInfo);
            
            // 4. 创建合并后的对象
            String finalObjectName = uploadInfo.getFileName();
            List<ComposeSource> sources = new ArrayList<>();
            
            for (int i = 0; i < uploadInfo.getChunkCount(); i++) {
                String chunkObjectName = uploadId + "/" + i;
                sources.add(ComposeSource.builder()
                    .bucket(minioProperties.getBucketName())
                    .object(chunkObjectName)
                    .build());
            }
            
            // 5. 执行合并
            minioClient.composeObject(ComposeObjectArgs.builder()
                .bucket(minioProperties.getBucketName())
                .object(finalObjectName)
                .sources(sources)
                .build());
            
            // 6. 删除分片文件
            deleteChunkFiles(uploadId, uploadInfo.getChunkCount());
            
            // 7. 更新状态为完成
            uploadInfo.setStatus("COMPLETED");
            uploadInfo.setFinalObjectName(finalObjectName);
            uploadInfo.setCompleteTime(LocalDateTime.now());
            updateUploadInfo(uploadInfo);
            
            // 8. 更新进度为完成
            progressService.completeProgress(uploadId);
            
            log.info("分片合并完成: uploadId={}, fileName={}", uploadId, uploadInfo.getFileName());
            
            return ChunkMergeResult.success(finalObjectName);
            
        } catch (Exception e) {
            log.error("分片合并失败: uploadId={}", uploadId, e);
            
            // 更新状态为失败
            ChunkUploadInfo uploadInfo = getUploadInfo(uploadId);
            if (uploadInfo != null) {
                uploadInfo.setStatus("FAILED");
                uploadInfo.setErrorMessage(e.getMessage());
                updateUploadInfo(uploadInfo);
            }
            
            return ChunkMergeResult.error("分片合并失败: " + e.getMessage());
        }
    }
    
    /**
     * 获取上传信息
     * @param uploadId 上传ID
     * @return 上传信息
     */
    public ChunkUploadInfo getUploadInfo(String uploadId) {
        String key = "chunk:upload:" + uploadId;
        return (ChunkUploadInfo) redisTemplate.opsForValue().get(key);
    }
    
    /**
     * 更新上传信息
     * @param uploadInfo 上传信息
     */
    private void updateUploadInfo(ChunkUploadInfo uploadInfo) {
        String key = "chunk:upload:" + uploadInfo.getUploadId();
        redisTemplate.opsForValue().set(key, uploadInfo, Duration.ofHours(24));
    }
    
    /**
     * 删除分片文件
     * @param uploadId 上传ID
     * @param chunkCount 分片数量
     */
    private void deleteChunkFiles(String uploadId, int chunkCount) {
        try {
            List<DeleteObject> objects = new ArrayList<>();
            
            for (int i = 0; i < chunkCount; i++) {
                String chunkObjectName = uploadId + "/" + i;
                objects.add(new DeleteObject(chunkObjectName));
            }
            
            Iterable<Result<DeleteError>> results = minioClient.removeObjects(
                RemoveObjectsArgs.builder()
                    .bucket(minioProperties.getBucketName())
                    .objects(objects)
                    .build());
            
            // 检查删除结果
            for (Result<DeleteError> result : results) {
                DeleteError error = result.get();
                if (error != null) {
                    log.warn("删除分片文件失败: {}", error.objectName());
                }
            }
            
        } catch (Exception e) {
            log.error("删除分片文件失败: uploadId={}", uploadId, e);
        }
    }
    
    /**
     * 生成上传ID
     * @param fileName 文件名
     * @return 上传ID
     */
    private String generateUploadId(String fileName) {
        String timestamp = String.valueOf(System.currentTimeMillis());
        String uuid = UUID.randomUUID().toString().substring(0, 8);
        return fileName + "_" + timestamp + "_" + uuid;
    }
}

/**
 * 分片上传信息
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ChunkUploadInfo {
    private String uploadId;
    private String fileName;
    private long fileSize;
    private int chunkCount;
    private Set<Integer> uploadedChunks;
    private String status;
    private String finalObjectName;
    private String errorMessage;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
    private LocalDateTime completeTime;
}

/**
 * 分片上传结果
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ChunkUploadResult {
    private boolean success;
    private String message;
    private int uploadedChunks;
    private int totalChunks;
    
    public static ChunkUploadResult success(String message) {
        return ChunkUploadResult.builder()
            .success(true)
            .message(message)
            .build();
    }
    
    public static ChunkUploadResult error(String message) {
        return ChunkUploadResult.builder()
            .success(false)
            .message(message)
            .build();
    }
}

/**
 * 分片合并结果
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ChunkMergeResult {
    private boolean success;
    private String objectName;
    private String message;
    
    public static ChunkMergeResult success(String objectName) {
        return ChunkMergeResult.builder()
            .success(true)
            .objectName(objectName)
            .build();
    }
    
    public static ChunkMergeResult error(String message) {
        return ChunkMergeResult.builder()
            .success(false)
            .message(message)
            .build();
    }
}

/**
 * 断点续传服务
 */
@Service
public class ResumeUploadService {
    
    @Autowired
    private ChunkUploadService chunkUploadService;
    
    @Autowired
    private UploadProgressService progressService;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    /**
     * 检查上传状态
     * @param uploadId 上传ID
     * @return 上传状态
     */
    public UploadStatus checkUploadStatus(String uploadId) {
        try {
            ChunkUploadInfo uploadInfo = chunkUploadService.getUploadInfo(uploadId);
            if (uploadInfo == null) {
                return UploadStatus.notFound();
            }
            
            UploadStatus status = new UploadStatus();
            status.setUploadId(uploadId);
            status.setFileName(uploadInfo.getFileName());
            status.setFileSize(uploadInfo.getFileSize());
            status.setChunkCount(uploadInfo.getChunkCount());
            status.setUploadedChunks(uploadInfo.getUploadedChunks());
            status.setStatus(uploadInfo.getStatus());
            status.setProgress(calculateProgress(uploadInfo));
            
            return status;
            
        } catch (Exception e) {
            log.error("检查上传状态失败: uploadId={}", uploadId, e);
            return UploadStatus.error("检查上传状态失败: " + e.getMessage());
        }
    }
    
    /**
     * 恢复上传
     * @param uploadId 上传ID
     * @return 恢复结果
     */
    public ResumeResult resumeUpload(String uploadId) {
        try {
            ChunkUploadInfo uploadInfo = chunkUploadService.getUploadInfo(uploadId);
            if (uploadInfo == null) {
                return ResumeResult.error("上传信息不存在");
            }
            
            if ("COMPLETED".equals(uploadInfo.getStatus())) {
                return ResumeResult.success("上传已完成");
            }
            
            if ("FAILED".equals(uploadInfo.getStatus())) {
                return ResumeResult.error("上传已失败: " + uploadInfo.getErrorMessage());
            }
            
            // 检查哪些分片需要重新上传
            List<Integer> missingChunks = findMissingChunks(uploadInfo);
            
            ResumeResult result = new ResumeResult();
            result.setSuccess(true);
            result.setUploadId(uploadId);
            result.setMissingChunks(missingChunks);
            result.setMessage("可以继续上传");
            
            log.info("恢复上传成功: uploadId={}, missingChunks={}", uploadId, missingChunks.size());
            
            return result;
            
        } catch (Exception e) {
            log.error("恢复上传失败: uploadId={}", uploadId, e);
            return ResumeResult.error("恢复上传失败: " + e.getMessage());
        }
    }
    
    /**
     * 取消上传
     * @param uploadId 上传ID
     * @return 取消结果
     */
    public CancelResult cancelUpload(String uploadId) {
        try {
            ChunkUploadInfo uploadInfo = chunkUploadService.getUploadInfo(uploadId);
            if (uploadInfo == null) {
                return CancelResult.error("上传信息不存在");
            }
            
            // 更新状态为取消
            uploadInfo.setStatus("CANCELLED");
            uploadInfo.setUpdateTime(LocalDateTime.now());
            
            String key = "chunk:upload:" + uploadId;
            redisTemplate.opsForValue().set(key, uploadInfo, Duration.ofHours(1));
            
            // 删除已上传的分片
            deleteUploadedChunks(uploadId, uploadInfo.getUploadedChunks());
            
            // 清除进度
            progressService.clearProgress(uploadId);
            
            log.info("取消上传成功: uploadId={}", uploadId);
            
            return CancelResult.success("上传已取消");
            
        } catch (Exception e) {
            log.error("取消上传失败: uploadId={}", uploadId, e);
            return CancelResult.error("取消上传失败: " + e.getMessage());
        }
    }
    
    /**
     * 查找缺失的分片
     * @param uploadInfo 上传信息
     * @return 缺失的分片列表
     */
    private List<Integer> findMissingChunks(ChunkUploadInfo uploadInfo) {
        List<Integer> missingChunks = new ArrayList<>();
        
        for (int i = 0; i < uploadInfo.getChunkCount(); i++) {
            if (!uploadInfo.getUploadedChunks().contains(i)) {
                missingChunks.add(i);
            }
        }
        
        return missingChunks;
    }
    
    /**
     * 计算上传进度
     * @param uploadInfo 上传信息
     * @return 进度百分比
     */
    private double calculateProgress(ChunkUploadInfo uploadInfo) {
        if (uploadInfo.getChunkCount() == 0) {
            return 0.0;
        }
        
        return (double) uploadInfo.getUploadedChunks().size() / uploadInfo.getChunkCount() * 100;
    }
    
    /**
     * 删除已上传的分片
     * @param uploadId 上传ID
     * @param uploadedChunks 已上传的分片
     */
    private void deleteUploadedChunks(String uploadId, Set<Integer> uploadedChunks) {
        try {
            // 这里可以实现删除MinIO中已上传分片的逻辑
            log.debug("删除已上传分片: uploadId={}, count={}", uploadId, uploadedChunks.size());
            
        } catch (Exception e) {
            log.error("删除已上传分片失败: uploadId={}", uploadId, e);
        }
    }
}

/**
 * 上传状态
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class UploadStatus {
    private String uploadId;
    private String fileName;
    private long fileSize;
    private int chunkCount;
    private Set<Integer> uploadedChunks;
    private String status;
    private double progress;
    private String message;
    
    public static UploadStatus notFound() {
        return UploadStatus.builder()
            .status("NOT_FOUND")
            .message("上传信息不存在")
            .build();
    }
    
    public static UploadStatus error(String message) {
        return UploadStatus.builder()
            .status("ERROR")
            .message(message)
            .build();
    }
}

/**
 * 恢复结果
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ResumeResult {
    private boolean success;
    private String uploadId;
    private List<Integer> missingChunks;
    private String message;
    
    public static ResumeResult success(String message) {
        return ResumeResult.builder()
            .success(true)
            .message(message)
            .build();
    }
    
    public static ResumeResult error(String message) {
        return ResumeResult.builder()
            .success(false)
            .message(message)
            .build();
    }
}

/**
 * 取消结果
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class CancelResult {
    private boolean success;
    private String message;
    
    public static CancelResult success(String message) {
        return CancelResult.builder()
            .success(true)
            .message(message)
            .build();
    }
    
    public static CancelResult error(String message) {
        return CancelResult.builder()
            .success(false)
            .message(message)
            .build();
    }
}

/**
 * 上传进度服务
 */
@Service
public class UploadProgressService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private SimpMessagingTemplate messagingTemplate;
    
    /**
     * 初始化进度
     * @param uploadId 上传ID
     * @param totalChunks 总分片数
     */
    public void initProgress(String uploadId, int totalChunks) {
        try {
            UploadProgress progress = UploadProgress.builder()
                .uploadId(uploadId)
                .totalChunks(totalChunks)
                .uploadedChunks(0)
                .progress(0.0)
                .status("UPLOADING")
                .startTime(LocalDateTime.now())
                .build();
            
            String key = "upload:progress:" + uploadId;
            redisTemplate.opsForValue().set(key, progress, Duration.ofHours(24));
            
            // 发送进度通知
            sendProgressNotification(uploadId, progress);
            
        } catch (Exception e) {
            log.error("初始化进度失败: uploadId={}", uploadId, e);
        }
    }
    
    /**
     * 更新进度
     * @param uploadId 上传ID
     * @param chunkNumber 分片编号
     */
    public void updateProgress(String uploadId, int chunkNumber) {
        try {
            String key = "upload:progress:" + uploadId;
            UploadProgress progress = (UploadProgress) redisTemplate.opsForValue().get(key);
            
            if (progress != null) {
                progress.setUploadedChunks(progress.getUploadedChunks() + 1);
                progress.setProgress((double) progress.getUploadedChunks() / progress.getTotalChunks() * 100);
                progress.setUpdateTime(LocalDateTime.now());
                
                redisTemplate.opsForValue().set(key, progress, Duration.ofHours(24));
                
                // 发送进度通知
                sendProgressNotification(uploadId, progress);
            }
            
        } catch (Exception e) {
            log.error("更新进度失败: uploadId={}, chunkNumber={}", uploadId, chunkNumber, e);
        }
    }
    
    /**
     * 完成进度
     * @param uploadId 上传ID
     */
    public void completeProgress(String uploadId) {
        try {
            String key = "upload:progress:" + uploadId;
            UploadProgress progress = (UploadProgress) redisTemplate.opsForValue().get(key);
            
            if (progress != null) {
                progress.setStatus("COMPLETED");
                progress.setProgress(100.0);
                progress.setCompleteTime(LocalDateTime.now());
                
                redisTemplate.opsForValue().set(key, progress, Duration.ofHours(1));
                
                // 发送完成通知
                sendProgressNotification(uploadId, progress);
            }
            
        } catch (Exception e) {
            log.error("完成进度失败: uploadId={}", uploadId, e);
        }
    }
    
    /**
     * 失败进度
     * @param uploadId 上传ID
     * @param errorMessage 错误消息
     */
    public void failProgress(String uploadId, String errorMessage) {
        try {
            String key = "upload:progress:" + uploadId;
            UploadProgress progress = (UploadProgress) redisTemplate.opsForValue().get(key);
            
            if (progress != null) {
                progress.setStatus("FAILED");
                progress.setErrorMessage(errorMessage);
                progress.setFailTime(LocalDateTime.now());
                
                redisTemplate.opsForValue().set(key, progress, Duration.ofHours(1));
                
                // 发送失败通知
                sendProgressNotification(uploadId, progress);
            }
            
        } catch (Exception e) {
            log.error("失败进度失败: uploadId={}", uploadId, e);
        }
    }
    
    /**
     * 清除进度
     * @param uploadId 上传ID
     */
    public void clearProgress(String uploadId) {
        try {
            String key = "upload:progress:" + uploadId;
            redisTemplate.delete(key);
            
        } catch (Exception e) {
            log.error("清除进度失败: uploadId={}", uploadId, e);
        }
    }
    
    /**
     * 获取进度
     * @param uploadId 上传ID
     * @return 进度信息
     */
    public UploadProgress getProgress(String uploadId) {
        try {
            String key = "upload:progress:" + uploadId;
            return (UploadProgress) redisTemplate.opsForValue().get(key);
            
        } catch (Exception e) {
            log.error("获取进度失败: uploadId={}", uploadId, e);
            return null;
        }
    }
    
    /**
     * 发送进度通知
     * @param uploadId 上传ID
     * @param progress 进度信息
     */
    private void sendProgressNotification(String uploadId, UploadProgress progress) {
        try {
            ProgressNotification notification = ProgressNotification.builder()
                .uploadId(uploadId)
                .progress(progress.getProgress())
                .uploadedChunks(progress.getUploadedChunks())
                .totalChunks(progress.getTotalChunks())
                .status(progress.getStatus())
                .timestamp(LocalDateTime.now())
                .build();
            
            messagingTemplate.convertAndSend("/topic/upload-progress/" + uploadId, notification);
            
        } catch (Exception e) {
            log.error("发送进度通知失败: uploadId={}", uploadId, e);
        }
    }
}

/**
 * 上传进度
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class UploadProgress {
    private String uploadId;
    private int totalChunks;
    private int uploadedChunks;
    private double progress;
    private String status;
    private String errorMessage;
    private LocalDateTime startTime;
    private LocalDateTime updateTime;
    private LocalDateTime completeTime;
    private LocalDateTime failTime;
}

/**
 * 进度通知
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ProgressNotification {
    private String uploadId;
    private double progress;
    private int uploadedChunks;
    private int totalChunks;
    private String status;
    private LocalDateTime timestamp;
}

/**
 * 文件上传控制器
 */
@RestController
@RequestMapping("/api/upload")
public class FileUploadController {
    
    @Autowired
    private ChunkUploadService chunkUploadService;
    
    @Autowired
    private ResumeUploadService resumeUploadService;
    
    @Autowired
    private UploadProgressService progressService;
    
    /**
     * 初始化分片上传
     */
    @PostMapping("/init")
    public ResponseEntity<Map<String, Object>> initChunkUpload(
            @RequestParam String fileName,
            @RequestParam long fileSize,
            @RequestParam int chunkCount) {
        
        try {
            String uploadId = chunkUploadService.initChunkUpload(fileName, fileSize, chunkCount);
            
            Map<String, Object> result = new HashMap<>();
            result.put("success", true);
            result.put("uploadId", uploadId);
            result.put("chunkSize", 5242880); // 5MB
            
            return ResponseEntity.ok(result);
            
        } catch (Exception e) {
            log.error("初始化分片上传失败: fileName={}", fileName, e);
            
            Map<String, Object> result = new HashMap<>();
            result.put("success", false);
            result.put("message", e.getMessage());
            
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(result);
        }
    }
    
    /**
     * 上传分片
     */
    @PostMapping("/chunk")
    public ResponseEntity<Map<String, Object>> uploadChunk(
            @RequestParam String uploadId,
            @RequestParam int chunkNumber,
            @RequestParam("file") MultipartFile file) {
        
        try {
            byte[] chunkData = file.getBytes();
            ChunkUploadResult result = chunkUploadService.uploadChunk(uploadId, chunkNumber, chunkData);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", result.isSuccess());
            response.put("message", result.getMessage());
            
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            log.error("上传分片失败: uploadId={}, chunkNumber={}", uploadId, chunkNumber, e);
            
            Map<String, Object> result = new HashMap<>();
            result.put("success", false);
            result.put("message", e.getMessage());
            
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(result);
        }
    }
    
    /**
     * 检查上传状态
     */
    @GetMapping("/status/{uploadId}")
    public ResponseEntity<UploadStatus> checkUploadStatus(@PathVariable String uploadId) {
        try {
            UploadStatus status = resumeUploadService.checkUploadStatus(uploadId);
            return ResponseEntity.ok(status);
            
        } catch (Exception e) {
            log.error("检查上传状态失败: uploadId={}", uploadId, e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
        }
    }
    
    /**
     * 恢复上传
     */
    @PostMapping("/resume/{uploadId}")
    public ResponseEntity<ResumeResult> resumeUpload(@PathVariable String uploadId) {
        try {
            ResumeResult result = resumeUploadService.resumeUpload(uploadId);
            return ResponseEntity.ok(result);
            
        } catch (Exception e) {
            log.error("恢复上传失败: uploadId={}", uploadId, e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
        }
    }
    
    /**
     * 取消上传
     */
    @PostMapping("/cancel/{uploadId}")
    public ResponseEntity<CancelResult> cancelUpload(@PathVariable String uploadId) {
        try {
            CancelResult result = resumeUploadService.cancelUpload(uploadId);
            return ResponseEntity.ok(result);
            
        } catch (Exception e) {
            log.error("取消上传失败: uploadId={}", uploadId, e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
        }
    }
    
    /**
     * 获取上传进度
     */
    @GetMapping("/progress/{uploadId}")
    public ResponseEntity<UploadProgress> getUploadProgress(@PathVariable String uploadId) {
        try {
            UploadProgress progress = progressService.getProgress(uploadId);
            if (progress != null) {
                return ResponseEntity.ok(progress);
            } else {
                return ResponseEntity.notFound().build();
            }
            
        } catch (Exception e) {
            log.error("获取上传进度失败: uploadId={}", uploadId, e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
        }
    }
}

/**
 * WebSocket配置
 */
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
    
    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        config.enableSimpleBroker("/topic");
        config.setApplicationDestinationPrefixes("/app");
    }
    
    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/ws")
            .setAllowedOriginPatterns("*")
            .withSockJS();
    }
}

/**
 * WebSocket控制器
 */
@Controller
public class WebSocketController {
    
    @MessageMapping("/upload/progress")
    @SendTo("/topic/upload-progress")
    public ProgressNotification handleProgressMessage(ProgressRequest request) {
        // 处理进度消息
        return ProgressNotification.builder()
            .uploadId(request.getUploadId())
            .progress(request.getProgress())
            .status(request.getStatus())
            .timestamp(LocalDateTime.now())
            .build();
    }
}

/**
 * 进度请求
 */
@Data
public class ProgressRequest {
    private String uploadId;
    private double progress;
    private String status;
}