SpringBoot 整合 FFmpeg 的工具类

原创 于 2025-10-23 15:56:03 发布 · 356 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring boot #ffmpeg #后端

以下是一个完整的 SpringBoot 整合 FFmpeg 的工具类：

1. 配置类

package com.example.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "ffmpeg")
public class FfmpegProperties {
    
    private String path = "ffmpeg";  // 默认使用系统PATH中的ffmpeg
    private int timeout = 300;       // 命令执行超时时间（秒）
    private int maxThreads = 4;      // 最大线程数
    
    // getters and setters
    public String getPath() {
        return path;
    }
    
    public void setPath(String path) {
        this.path = path;
    }
    
    public int getTimeout() {
        return timeout;
    }
    
    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }
    
    public int getMaxThreads() {
        return maxThreads;
    }
    
    public void setMaxThreads(int maxThreads) {
        this.maxThreads = maxThreads;
    }
}

2. 完整的 FFmpeg 工具类

package com.example.util;

import com.example.config.FfmpegProperties;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

@Component
public class FfmpegUtil {
    
    private static final Logger logger = LoggerFactory.getLogger(FfmpegUtil.class);
    
    @Autowired
    private FfmpegProperties ffmpegProperties;
    
    /**
     * 执行FFmpeg命令
     */
    public boolean execCmd(String[] cmd) {
        return execCmd(cmd, null);
    }
    
    /**
     * 执行FFmpeg命令（带输出处理）
     */
    public boolean execCmd(String[] cmd, OutputHandler outputHandler) {
        ProcessBuilder processBuilder = new ProcessBuilder(cmd);
        processBuilder.redirectErrorStream(true);  // 合并标准错误和标准输出
        
        try {
            Process process = processBuilder.start();
            
            // 处理输出流
            if (outputHandler != null) {
                handleOutput(process, outputHandler);
            }
            
            // 等待进程完成
            boolean finished = process.waitFor(ffmpegProperties.getTimeout(), TimeUnit.SECONDS);
            if (!finished) {
                process.destroyForcibly();
                logger.error("FFmpeg命令执行超时: {}", String.join(" ", cmd));
                return false;
            }
            
            int exitValue = process.exitValue();
            if (exitValue == 0) {
                logger.info("FFmpeg命令执行成功: {}", String.join(" ", cmd));
                return true;
            } else {
                logger.error("FFmpeg命令执行失败，退出码: {}, 命令: {}", exitValue, String.join(" ", cmd));
                return false;
            }
            
        } catch (IOException | InterruptedException e) {
            logger.error("FFmpeg命令执行异常: {}", e.getMessage(), e);
            return false;
        }
    }
    
    /**
     * 处理输出流
     */
    private void handleOutput(Process process, OutputHandler outputHandler) {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {
            String line;
            while ((line = reader.readLine()) != null) {
                outputHandler.handle(line);
            }
        } catch (IOException e) {
            logger.error("处理FFmpeg输出流异常: {}", e.getMessage());
        }
    }
    
    /**
     * 音频转码为WAV格式
     */
    public boolean audioToWav(String inputPath, String outputPath) {
        return audioToWav(inputPath, outputPath, 44100, 2, 16);
    }
    
    /**
     * 音频转码为WAV格式（自定义参数）
     */
    public boolean audioToWav(String inputPath, String outputPath, 
                             Integer sampleRate, Integer channels, Integer bitDepth) {
        // 输出文件预处理
        File outputFile = new File(outputPath);
        prepareOutputFile(outputFile);
        
        // 设置默认参数
        if (sampleRate == null) sampleRate = 44100;
        if (channels == null) channels = 2;
        if (bitDepth == null) bitDepth = 16;
        
        // 根据位深度选择PCM格式
        String pcmFormat = getPcmFormat(bitDepth);
        
        // 构建FFmpeg命令
        String[] cmd = new String[]{
            ffmpegProperties.getPath(),
            "-i", inputPath,
            "-c:a", pcmFormat,
            "-ac", channels.toString(),
            "-ar", sampleRate.toString(),
            "-f", "wav",
            "-y",
            outputPath
        };
        
        logger.info("音频转码WAV: {} -> {}", inputPath, outputPath);
        return execCmd(cmd);
    }
    
    /**
     * 视频转码为指定编码格式
     */
    public boolean videoTranscoding(String inputPath, String outputPath) {
        return videoTranscoding(inputPath, outputPath, "libx264", "medium", 23);
    }
    
    /**
     * 视频转码（自定义参数）
     */
    public boolean videoTranscoding(String inputPath, String outputPath, 
                                   String codec, String preset, Integer crf) {
        File outputFile = new File(outputPath);
        prepareOutputFile(outputFile);
        
        if (preset == null) preset = "medium";
        if (crf == null) crf = 23;
        
        String[] cmd = new String[]{
            ffmpegProperties.getPath(),
            "-threads", String.valueOf(ffmpegProperties.getMaxThreads()),
            "-i", inputPath,
            "-c:v", codec,
            "-preset", preset,
            "-crf", crf.toString(),
            "-c:a", "aac",
            "-b:a", "128k",
            "-movflags", "+faststart",  // 优化网络播放
            "-f", "mp4",
            "-y",
            outputPath
        };
        
        logger.info("视频转码: {} -> {}", inputPath, outputPath);
        return execCmd(cmd);
    }
    
    /**
     * 提取视频中的音频
     */
    public boolean extractAudio(String videoPath, String audioPath) {
        File outputFile = new File(audioPath);
        prepareOutputFile(outputFile);
        
        String[] cmd = new String[]{
            ffmpegProperties.getPath(),
            "-i", videoPath,
            "-vn",           // 禁用视频流
            "-acodec", "copy", // 直接复制音频流
            "-y",
            audioPath
        };
        
        logger.info("提取音频: {} -> {}", videoPath, audioPath);
        return execCmd(cmd);
    }
    
    /**
     * 获取媒体文件信息
     */
    public MediaInfo getMediaInfo(String filePath) {
        List<String> outputLines = new ArrayList<>();
        OutputHandler handler = outputLines::add;
        
        String[] cmd = new String[]{
            ffmpegProperties.getPath(),
            "-i", filePath
        };
        
        // 这个命令会失败（因为缺少输出文件），但我们可以从错误输出中获取信息
        execCmd(cmd, handler);
        
        return parseMediaInfo(outputLines, filePath);
    }
    
    /**
     * 解析媒体信息
     */
    private MediaInfo parseMediaInfo(List<String> outputLines, String filePath) {
        MediaInfo info = new MediaInfo();
        info.setFilePath(filePath);
        
        for (String line : outputLines) {
            // 解析时长
            if (line.contains("Duration:")) {
                String duration = line.split("Duration:")[1].split(",")[0].trim();
                info.setDuration(duration);
            }
            // 解析视频流信息
            else if (line.contains("Video:")) {
                info.setVideoStream(true);
                if (line.contains("h264")) info.setVideoCodec("H.264");
                else if (line.contains("hevc")) info.setVideoCodec("H.265");
                // 可以添加更多解析逻辑
            }
            // 解析音频流信息
            else if (line.contains("Audio:")) {
                info.setAudioStream(true);
                if (line.contains("aac")) info.setAudioCodec("AAC");
                else if (line.contains("mp3")) info.setAudioCodec("MP3");
            }
        }
        
        return info;
    }
    
    /**
     * 获取PCM格式
     */
    private String getPcmFormat(int bitDepth) {
        switch (bitDepth) {
            case 8: return "pcm_u8";
            case 24: return "pcm_s24le";
            case 32: return "pcm_s32le";
            default: return "pcm_s16le";
        }
    }
    
    /**
     * 准备输出文件
     */
    private void prepareOutputFile(File outputFile) {
        if (outputFile.exists()) {
            outputFile.delete();
        }
        File parentDir = outputFile.getParentFile();
        if (parentDir != null && !parentDir.exists()) {
            parentDir.mkdirs();
        }
    }
    
    /**
     * 输出处理器接口
     */
    public interface OutputHandler {
        void handle(String line);
    }
    
    /**
     * 媒体信息类
     */
    public static class MediaInfo {
        private String filePath;
        private String duration;
        private boolean videoStream;
        private boolean audioStream;
        private String videoCodec;
        private String audioCodec;
        
        // getters and setters
        public String getFilePath() { return filePath; }
        public void setFilePath(String filePath) { this.filePath = filePath; }
        public String getDuration() { return duration; }
        public void setDuration(String duration) { this.duration = duration; }
        public boolean isVideoStream() { return videoStream; }
        public void setVideoStream(boolean videoStream) { this.videoStream = videoStream; }
        public boolean isAudioStream() { return audioStream; }
        public void setAudioStream(boolean audioStream) { this.audioStream = audioStream; }
        public String getVideoCodec() { return videoCodec; }
        public void setVideoCodec(String videoCodec) { this.videoCodec = videoCodec; }
        public String getAudioCodec() { return audioCodec; }
        public void setAudioCodec(String audioCodec) { this.audioCodec = audioCodec; }
        
        @Override
        public String toString() {
            return String.format("MediaInfo{filePath='%s', duration='%s', videoStream=%s, audioStream=%s, videoCodec='%s', audioCodec='%s'}",
                    filePath, duration, videoStream, audioStream, videoCodec, audioCodec);
        }
    }
}

3. 应用配置文件

# application.yml
ffmpeg:
  path: /usr/local/bin/ffmpeg  # Windows: C:/ffmpeg/bin/ffmpeg.exe
  timeout: 300                 # 5分钟超时
  max-threads: 4               # 最大线程数

4. 控制器示例

package com.example.controller;

import com.example.util.FfmpegUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

@RestController
@RequestMapping("/api/media")
public class MediaController {
    
    @Autowired
    private FfmpegUtil ffmpegUtil;
    
    @PostMapping("/convert-to-wav")
    public Map<String, Object> convertToWav(@RequestParam("file") MultipartFile file) {
        Map<String, Object> result = new HashMap<>();
        
        try {
            // 保存上传文件
            String originalFileName = file.getOriginalFilename();
            String tempDir = System.getProperty("java.io.tmpdir");
            String inputPath = tempDir + File.separator + originalFileName;
            String outputPath = tempDir + File.separator + 
                originalFileName.replaceFirst("\\.[^.]+$", "") + ".wav";
            
            file.transferTo(new File(inputPath));
            
            // 执行转换
            boolean success = ffmpegUtil.audioToWav(inputPath, outputPath);
            
            result.put("success", success);
            result.put("outputFile", outputPath);
            if (success) {
                result.put("message", "转换成功");
            } else {
                result.put("message", "转换失败");
            }
            
            // 清理临时文件
            new File(inputPath).delete();
            
        } catch (IOException e) {
            result.put("success", false);
            result.put("message", "文件处理异常: " + e.getMessage());
        }
        
        return result;
    }
    
    @GetMapping("/media-info")
    public FfmpegUtil.MediaInfo getMediaInfo(@RequestParam String filePath) {
        return ffmpegUtil.getMediaInfo(filePath);
    }
}

5. 异常处理类

package com.example.handler;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import java.util.HashMap;
import java.util.Map;

@RestControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(Exception.class)
    public ResponseEntity<Map<String, Object>> handleException(Exception 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);
    }
}

6. 使用示例

@Service
public class MediaService {
    
    @Autowired
    private FfmpegUtil ffmpegUtil;
    
    public void processMedia() {
        // 音频转WAV
        boolean success = ffmpegUtil.audioToWav(
            "/path/to/input.mp3", 
            "/path/to/output.wav",
            48000, 2, 16
        );
        
        // 获取媒体信息
        FfmpegUtil.MediaInfo info = ffmpegUtil.getMediaInfo("/path/to/video.mp4");
        System.out.println("视频时长: " + info.getDuration());
        
        // 视频转码
        ffmpegUtil.videoTranscoding(
            "/path/to/input.avi",
            "/path/to/output.mp4",
            "libx264", "medium", 23
        );
    }
}

主要特性

  1. 配置化：通过配置文件管理 FFmpeg 路径和参数
  2. 异常处理：完善的异常处理和日志记录
  3. 灵活的输出处理：支持实时处理 FFmpeg 输出
  4. 超时控制：防止长时间运行的命令阻塞系统
  5. 多种媒体操作：支持音视频转码、信息提取等
  6. RESTful API：提供 Web 接口方便调用

这个工具类可以直接集成到 SpringBoot 项目中使用，提供了完整的媒体处理能力。

SpringBoot + FFmpeg 进行视频分片上传实战演练
迟到的微笑
04-11 4078
文章目录前言一、FFmpeg是什么？有命令？1.ffmpeg(命令行工具) 是一个快速的音视频转换工具2.[命令大全](https://www.jianshu.com/p/df3216a52e59)二、安装FFmpeg1.[官网下载](http://ffmpeg.org/download.html)2设置环境变量3 开始实战编码3.1 pom FFmpeg依赖3.2 关键切片TranscodeInfo实体类3.3切片工具类关键的方法3.4 配置文件3.5 html 文件总结 前言 提示：这里可以添加本文要
SpringBoot 集成 FFMPEG 简单合成视频
NO_DE_BUG的博客
09-03 774
链接: https://pan.baidu.com/s/1aMi-M9Aa9GSPDuCIw2zPeg?pwd=ggby 提 取码: ggby (通过网盘分享的文件：ffmpeg-7.0.2-essentials_build.zip。FFMpeg版本：ffmpeg-7.0.2-essentials。需要注意的事项已在代码中标注！SpringBoot 版本：2.7。开发环境：Windows。此代码是简化过后的，如果需要源码，请留言。
SpringBoot整合FFmpeg进行视频分片上传（Linux）
weixin_45817985的博客
08-21 3506
SpringBoot整合FFmpeg进行视频分片上传（Linux）
spring boot 整合ffmpeg(java与ffmpeg整合)
热门推荐
qq_39190628的博客
01-24 2万+
spring boot 整合 ffmpeg （java 整合ffmpeg）
SpringBoot集成ffmpeg实现视频转码播放
月月鸟先森的博客
09-18 5092
之前构建过文件预览服务，对于视频部分前端播放组件限制只能为mp4格式，为了支持更多视频格式决定对方案进行升级，由于视频格式较多，针对每一种格式定制选择播放器不太现实，决定对视频源统一转码，转码后的格式为mp4，兼容性稳定且前后端改造工作较小。
SpringBoot 集成 FFmpeg 解析音视频
Mrqiang9001
05-11 3180
FFmpeg 是最常用的跨平台的音频、视频处理软件，但是其通过命令行的方式进行操作对于普通用户而言上手难度大，同时 FFmpeg 只是函数库，对于不同的编程语言，需要自行适配API接口，以便于操作文件。本文介绍SpringBoot 集成 FFmpeg 实现对音视频文件的解析。FFmpeg 官网:FFmpeg Java 平台常用适配仓库:JavaCV :JavaCV 是一个集成第三方函数库的平台，包括 OpenCV、FFmpeg 等知名函数库，提供统一的 API 操作，应用广泛。
【实战】SpringBoot整合ffmpeg实现动态拉流转推
weixin_48471044的博客
07-30 4173
在最近的开发中，遇到一个 rtsp 协议的视频流，前端vue并不能直接播放，因此需要对流进行处理。在网上查阅后，ffmpeg和webrtc是最多的解决方案，但是使用webrtc的时候没成功，所以选择ffmpeg。免密登录需要将公钥复制到被登录的目标服务器，在现在需求中，需要在容器中远程登录宿主机，所以宿主机就是目标服务器，那么换个思路，将这里生成的私钥，放在容器中，就可以从容器中远程登录宿主机。下面介绍一下整体的实现步骤。现在最简单的demo就已经完成了，但是这样的实现方式需要手动控制，
SpringBoot整合FFmpeg进行视频分片上传
qq_54673740的博客
07-30 1373
SpringBoot整合FFmpeg进行视频分片上传------>Windows 分片上传的核心思路： 将文件按一定的分割规则（静态或动态设定，如手动设置20M为一个分片），用slice分割成多个数据块。 为每个文件生成一个唯一标识Key，用于多数据块上传时区分所属文件。 所有分片上传完成，服务端校验合并标识为Key的所有分片为一个最终文件。 分片上传的意义： 将文件分片上传，在网络环境不佳时，可以对文件上传失败的部分重新上传，避免了每次上传都需要从文件起始位置上传的问题。分片的附带好处还能很方便
springboot整合ffmpeg
06-28
编写一个FFmpeg工具类，用于调用FFmpeg命令进行音视频处理。例如： ``` public class FFmpegUtil { public static void convert(String inputPath, String outputPath) throws Exception { FFmpeg ffmpeg = new ...
springboot整合ffmpeg 实现缩略图处理，元数据提取
最新发布
06-18
2.在SpringBoot项目中，我们可以创建一个工具类来封装FFmpeg的命令调用。3.对于缩略图生成，通常使用FFmpeg的截取视频帧功能。4.对于元数据提取，我们可以使用FFmpeg获取视频的详细信息（如时长、分辨率、帧率等）。...
springboot + FFmpeg 实战视频切片
04-11
springboot + FFmpeg 实战视频切片，主要用于大视频切片上传处理。客户端上传视频到服务器，服务器对视频进行切片后，返回m3u8，封面等访问路径。可以在线的播放。 服务器可以对视频做一些简单的处理，例如裁剪，封面的截取时间。
springboot+ffmpeg进行图片、音频、视频处理
qq_50867577的博客
12-28 3353
springboot操作ffmpeg完成对图片、音频、视频的一些处理，包括图片翻转，音频裁剪、拼接，视频裁剪、倍速、水印、拼接等
Spring boot集成ffmpeg实现视频极速播放
weixin_74905854的博客
09-15 4330
本文介绍了如何在 Spring Boot 应用中集成 FFmpeg 来实现视频切片播放的功能。视频切片技术，如 HLS，能够提高用户体验，减少服务器负载，并适应不同的网络条件。文章详细阐述了集成 FFmpeg 的步骤，包括项目结构的设置、所需依赖的添加、配置类的编写、工具类的实现、控制器的补充以及前端代码的编写。此外，还提供了如何生成视频切片文件的方法和前端播放器的实现示例。文章还讨论了跨域问题的解决方案，包括使用 @CrossOrigin 注解或 WebConfig 类来配置 CORS。最后，文章通过一个
SpringBoot + FFmpeg实现一个简单的M3U8切片转码系统
weixin_52721608的博客
09-07 2840
在本文中，我们将使用SpringBoot和FFmpeg来实现一个简单的M3U8切片转码系统。M3U8是一种常用的视频流媒体播放列表格式，而FFmpeg则是一个强大的音视频处理工具。我们的目标是建立一个系统，能够接收用户上传的视频文件，并将其转换为M3U8格式的切片文件，以便于在网络上进行流媒体传输。用户上传视频文件；将视频文件使用FFmpeg进行转码，生成M3U8切片文件；将生成的M3U8文件保存到服务器上；提供一个API接口供用户获取转码后的M3U8地址。
【亲测免费】 探索SpringBoot与FFmpeg集成的神奇：Springboot-ffmpeg-demo项目
gitblog_00060的博客
04-23 1035
探索SpringBoot与FFmpeg集成的神奇：Springboot-ffmpeg-demo项目 该项目 () 是一个基于Spring Boot的应用程序，它巧妙地集成了FFmpeg库，为开发者提供了一种在服务器端处理多媒体文件的新方式。这篇文章将深入解析这个项目的背景、技术细节、应用场景和独特之处。 1. 项目概述 springboot-ffmpeg-demo 是一个示例应用，展示了如何在Ja...
使用Spring Boot实现FFmpeg视频上传和压缩
DevNinja的博客
09-12 1123
您已成功实现了使用Spring Boot和FFmpeg进行视频上传和压缩的功能。用户现在可以上传视频文件，并在后台使用FFmpeg对视频进行压缩处理。您可以根据需要对压缩参数进行修改，并根据实际需求扩展应用程序的功能。在这篇文章中，我将向您展示如何使用Spring Boot框架和FFmpeg库实现视频上传和压缩功能。我们将编写一个Java应用程序，该应用程序允许用户上传视频文件，并在上传后使用FFmpeg进行压缩处理。上传完成后，应用程序将使用FFmpeg对视频进行压缩，并将用户重定向回上传页面。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

BirdMan98

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值