@RestController@RequestMapping("/api/video")public class VideoController {

    @Value("${video.storage-path}")
    private String storagePath;

    @Value("${video.max-shard-size}")
    private long maxShardSize;

    // 确保存储目录存在
    @PostConstruct
    public void init() {
        File dir = new File(storagePath);
        if (!dir.exists()) {
            dir.mkdirs();
        }
    }

    /**
     * 分片上传视频
     * @param file 分片文件
     * @param fileName 原文件名（含后缀）
     * @param chunkIndex 分片索引（从0开始）
     * @param totalChunks 总分片数
     * @return 上传结果
     */
    @PostMapping("/upload/shard")
    public Result<?> uploadShard(@RequestParam("file") MultipartFile file,
                                 @RequestParam("fileName") String fileName,
                                 @RequestParam("chunkIndex") int chunkIndex,
                                 @RequestParam("totalChunks") int totalChunks) {
        try {
            // 1. 生成临时分片存储目录（按文件名哈希，避免重名）
            String fileHash = DigestUtils.md5DigestAsHex(fileName.getBytes());
            String tempShardDir = storagePath + "temp/" + fileHash + "/";
            File tempDir = new File(tempShardDir);
            if (!tempDir.exists()) {
                tempDir.mkdirs();
            }

            // 2. 保存当前分片（文件名：分片索引）
            File shardFile = new File(tempShardDir + chunkIndex);
            file.transferTo(shardFile);

            // 3. 检查是否所有分片上传完成，若完成则合并
            if (chunkIndex == totalChunks - 1) {
                // 合并后的最终文件路径
                String finalFilePath = storagePath + fileName;
                File finalFile = new File(finalFilePath);

                // 4. 合并所有分片（按索引顺序）
                try (FileOutputStream outputStream = new FileOutputStream(finalFile)) {
                    for (int i = 0; i < totalChunks; i++) {
                        File currentShard = new File(tempShardDir + i);
                        byte[] bytes = FileUtils.readFileToByteArray(currentShard);
                        outputStream.write(bytes);
                        // 删除临时分片
                        currentShard.delete();
                    }
                }

                // 5. 删除临时分片目录
                FileUtils.deleteDirectory(tempDir);

                // （可选）生成HLS格式（需安装FFmpeg，调用命令行转码）
                generateHls(finalFilePath, storagePath + "hls/" + fileHash + "/");

                return Result.success("上传完成，视频路径：" + finalFilePath);
            }

            return Result.success("分片上传成功，当前分片：" + chunkIndex);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("分片上传失败：" + e.getMessage());
        }
    }

    /**
     * 生成HLS格式（.m3u8 + ts分片）
     * @param sourcePath 原视频路径
     * @param targetDir HLS输出目录
     */
    private void generateHls(String sourcePath, String targetDir) {
        File targetDirFile = new File(targetDir);
        if (!targetDirFile.exists()) {
            targetDirFile.mkdirs();
        }

        // FFmpeg命令：将MP4转为HLS（10秒分片，支持自适应码率）
        String command = String.format(
            "ffmpeg -i %s -profile:v baseline -level 3.0 -hls_time 10 -hls_list_size 0 -f hls %s/index.m3u8",
            sourcePath, targetDir        );

        try {
            // 执行命令行
            Process process = Runtime.getRuntime().exec(command);
            process.waitFor();
        } catch (Exception e) {
            e.printStackTrace();
            System.err.println("HLS转码失败：" + e.getMessage());
        }
    }}

/**
 * 视频流式播放（支持断点续传）
 * @param fileName 视频文件名（含后缀）
 * @param request 请求（获取Range头）
 * @param response 响应（返回视频流）
 */@GetMapping("/play/{fileName}")public void playVideo(@PathVariable("fileName") String fileName,
                      HttpServletRequest request,
                      HttpServletResponse response) {
    File videoFile = new File(storagePath + fileName);
    if (!videoFile.exists()) {
        response.setStatus(HttpServletResponse.SC_NOT_FOUND);
        return;
    }

    long fileLength = videoFile.length();
    // 解析Range请求头（格式：bytes=0-1023）
    String range = request.getHeader("Range");
    long start = 0;
    long end = fileLength - 1;

    if (range != null && range.startsWith("bytes=")) {
        String[] rangeArr = range.split("=")[1].split("-");
        start = Long.parseLong(rangeArr[0]);
        if (rangeArr.length > 1 && !rangeArr[1].isEmpty()) {
            end = Long.parseLong(rangeArr[1]);
        }
    }

    // 计算响应的字节长度
    long contentLength = end - start + 1;

    // 设置响应头（支持断点续传）
    response.setStatus(HttpServletResponse.SC_PARTIAL_CONTENT);
    response.setContentType(getContentType(fileName)); // 动态设置MIME类型
    response.setHeader("Content-Range", "bytes " + start + "-" + end + "/" + fileLength);
    response.setHeader("Accept-Ranges", "bytes");
    response.setContentLengthLong(contentLength);

    // 流式输出视频数据
    try (RandomAccessFile raf = new RandomAccessFile(videoFile, "r");
         OutputStream outputStream = response.getOutputStream()) {
        raf.seek(start); // 定位到起始字节
        byte[] buffer = new byte[4096];
        int len;
        long remaining = contentLength;
        while (remaining > 0 && (len = raf.read(buffer, 0, (int) Math.min(buffer.length, remaining))) != -1) {
            outputStream.write(buffer, 0, len);
            remaining -= len;
        }
        outputStream.flush();
    } catch (Exception e) {
        e.printStackTrace();
    }}/**
 * 根据文件名获取MIME类型
 */private String getContentType(String fileName) {
    if (fileName.endsWith(".mp4")) return "video/mp4";
    if (fileName.endsWith(".m3u8")) return "application/x-mpegURL";
    if (fileName.endsWith(".ts")) return "video/MP2T";
    if (fileName.endsWith(".webm")) return "video/webm";
    return "application/octet-stream";}

@Configuration@EnableWebSecuritypublic class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/api/video/play/**").authenticated() // 播放接口需登录
            .antMatchers("/api/video/upload/**").hasRole("ADMIN") // 上传接口需管理员权限
            .anyRequest().permitAll()
            .and()
            .formLogin() // 表单登录（可替换为JWT令牌登录）
            .and()
            .csrf().disable();
    }

    // 测试用户（生产环境需对接数据库）
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user").password("{noop}123456").roles("USER")
            .and()
            .withUser("admin").password("{noop}admin123").roles("ADMIN");
    }}