JAVA获取音频时长

我就是我 2023-10-04 10:10 28阅读 0赞

##### 下载依赖jar #####

[https://download.csdn.net/download/qq\_38254635/16546842][https_download.csdn.net_download_qq_38254635_16546842]

##### 加载依赖,可导入maven仓库,也可以直接放在项目中 #####

这里直接放在项目中

<dependency>
            <groupId>jaudiotagger</groupId>
            <artifactId>jaudiotagger</artifactId>
            <version>2.2.6</version>
            <scope>system</scope>
            <systemPath>${
        project.basedir}/lib/jaudiotagger-2.2.6-SNAPSHOT.jar</systemPath>
        </dependency>
        <dependency>
            <groupId>jl</groupId>
            <artifactId>jl</artifactId>
            <version>1.0.1</version>
            <scope>system</scope>
            <systemPath>${
        project.basedir}/lib/jl1.0.1.jar</systemPath>
        </dependency>

##### 上传文件代码 #####

路径,大小,文件类型,可放在SpringBoot项目中的yml文件中  
参考链接 [https://blog.csdn.net/qq\_38254635/article/details/112033193][https_blog.csdn.net_qq_38254635_article_details_112033193]

package utils;
    
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.codec.digest.DigestUtils;
    import org.apache.commons.lang.time.DateFormatUtils;
    import org.springframework.web.multipart.MultipartFile;
    import javax.servlet.http.HttpServletRequest;
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Random;
    
    @Slf4j
    public class UploadAudioFile {
        
    
        private final static String basePath = "audio/";
        private final static String fileUploadPath = "/data/upload/";
        private final static String fileUploadType = "user,org,business";
        private final static String fileSizeMax = "100MB";
        private final static String audioType = "mp3,wav";
    
        /**
         * upload audio file
         * @param fileType file type example:ass,aud
         * @param file file stream
         * @param request request for IP address
         * @return the path of the file on the server
         */
        public Result uploadAudio(String fileType, MultipartFile file, HttpServletRequest request) {
        
            if(file.isEmpty() || file.getOriginalFilename().isEmpty()) return Result.error(1000, "不能上传空文件");
            if (!fileUploadType.contains(fileType.startsWith("/") ? fileType.substring(1) : fileType)) return Result.error(1000, "非法的文件上传路径");
            String fileExtension = file.getOriginalFilename().split("\\.")[file.getOriginalFilename().split("\\.").length - 1];
            if (!audioType.contains(fileExtension.toLowerCase())) return Result.error(1000, "文件类型有误,支持文件类型:" + audioType);
            Integer imageMaxByte = Integer.valueOf(fileSizeMax.substring(0, fileSizeMax.length() - 2)) * 1024 * 1024;
            if (file.getSize() > imageMaxByte) return Result.error(1000, "当前文件超过最大限制,支持大小:" + imageMaxByte + "MB");
            String fileMd5;
            try {
        
                fileMd5 = DigestUtils.md5Hex(file.getInputStream());
            } catch (Exception e) {
        
                return Result.error(1000, "当前验证文件md5失败");
            }
            Date now = new Date();
            String newFileName = DateFormatUtils.format(now, "yyyyMMddHHmmssSSS") + (new Random().nextInt(100) + 100) + "." + fileExtension;
            String newFileRoute = (basePath + (fileType.startsWith("/") ? fileType.substring(1) : fileType)).trim().replace(" ","") + getDatePath();
            log.info("文件信息：" + fileUploadPath + newFileRoute + newFileName);
            try {
        
                File filePath = new File(fileUploadPath + newFileRoute);
                if (!filePath.exists()) {
        
                    filePath.mkdirs();
                }
            } catch (Exception e) {
        
                log.error("creating folder on linux server error", e);
                return Result.error(1000, "服务端创建文件夹失败");
            }
            FileOutputStream fileOutputStream = null;
            try {
        
                fileOutputStream = new FileOutputStream(fileUploadPath + newFileRoute + newFileName);
                fileOutputStream.write(file.getBytes());
                fileOutputStream.close();
            } catch (Exception e) {
        
                return Result.error(1000, "服务端写入文件失败");
            } finally {
        
                if(null != fileOutputStream){
        
                    try {
        
                        fileOutputStream.close();
                    } catch (IOException e1){
        
                        log.error("close IO stream error", e1);
                    }
                }
            }
            Long duration = null;
            try {
        
                duration = AudioUtil.getAudioDuration(file, fileUploadPath + newFileRoute + newFileName, fileExtension);
                log.info("=================audio duration:" + duration + "second=================");
            } catch (Exception e){
        
                log.error("get audio duration error", e);
            }
            Map<String,Object> resultMap = new HashMap<>();
            resultMap.put("fileName", file.getOriginalFilename());
            resultMap.put("filePath", "upload/" + newFileRoute + newFileName);
            resultMap.put("duration", duration);
            return Result.success(resultMap);
        }
    
        private static String getDatePath(){
        
            return "/"+ DateFormatUtils.format(new Date(), "yyyy-MM-dd").replaceAll("-","/")+"/";
        }
    }

##### 获取音频时长代码 #####

package utils;
    
    import java.io.BufferedInputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import lombok.extern.slf4j.Slf4j;
    import org.jaudiotagger.audio.AudioFileIO;
    import org.jaudiotagger.audio.mp3.MP3AudioHeader;
    import org.jaudiotagger.audio.mp3.MP3File;
    import javazoom.jl.player.Player;
    import org.springframework.web.multipart.MultipartFile;
    import javax.sound.sampled.AudioInputStream;
    import javax.sound.sampled.AudioSystem;
    import javax.sound.sampled.Clip;
    import javax.sound.sampled.LineUnavailableException;
    import javax.sound.sampled.UnsupportedAudioFileException;
    
    /**
     * audio utils
     * get audio duration, supported formats : mp3, wav
     */
    @Slf4j
    public class AudioUtil {
        
    
        /**
         * get audio duration
         * @param file file
         * @param position file position
         * @param fileExtension file extension type
         * @return audio duration, the unit is seconds
         * @throws Exception exception
         */
        public static Long getAudioDuration(MultipartFile file, String position, String fileExtension) throws Exception{
        
            if(null == fileExtension || null == file) return null;
            switch (fileExtension.toLowerCase()){
        
                case "mp3":
                    return Long.valueOf(getMp3Duration(position));
                case "wav":
                    return getWavDuration(file);
            }
            return null;
        }
    
        /**
         * get wav audio duration
         * @param position file position
         * @return second
         * @throws LineUnavailableException the audio line not available
         * @throws UnsupportedAudioFileException the audio format not supported
         * @throws IOException file stream exception
         */
        public static Long getWavDuration(String position) throws LineUnavailableException, UnsupportedAudioFileException, IOException{
        
            Clip clip = AudioSystem.getClip();
            AudioInputStream audioInputStream = AudioSystem.getAudioInputStream(new BufferedInputStream(new FileInputStream(position)));
            clip.open(audioInputStream);
            return clip.getMicrosecondLength() / 1000000;
        }
    
        /**
         * get wav audio duration
         * @param file file
         * @return second
         * @throws LineUnavailableException the audio line not available
         * @throws UnsupportedAudioFileException the audio format not supported
         * @throws IOException file stream exception
         */
        public static Long getWavDuration(MultipartFile file) throws LineUnavailableException, UnsupportedAudioFileException, IOException{
        
            Clip clip = AudioSystem.getClip();
            AudioInputStream audioInputStream = AudioSystem.getAudioInputStream(new BufferedInputStream(file.getInputStream()));
            clip.open(audioInputStream);
            return clip.getMicrosecondLength() / 1000000;
        }
    
        /**
         * play audio
         * @param position file position
         */
        public static void playMp3File(String position) {
        
            try {
        
                BufferedInputStream buffer = new BufferedInputStream(new FileInputStream(position));
                Player player = new Player(buffer);
                player.play();
            } catch (Exception e) {
        
                log.error("play audio exception:", e);
            }
        }
    
        /**
         * get mp3 audio duration
         * @param position file position
         * @return second
         */
        public static Integer getMp3Duration(String position) {
        
            try {
        
                MP3File mp3File = (MP3File) AudioFileIO.read(new File(position));
                MP3AudioHeader audioHeader = (MP3AudioHeader) mp3File.getAudioHeader();
                return audioHeader.getTrackLength();
            } catch (Exception e) {
        
                log.error("get mp3 audio duration exception:", e);
            }
            return 0;
        }
    
        /**
         * play audio
         * @param multipartFile file
         */
        public static void playMp3File(MultipartFile multipartFile) {
        
            try {
        
                BufferedInputStream buffer = new BufferedInputStream(multipartFile.getInputStream());
                Player player = new Player(buffer);
                player.play();
            } catch (Exception e) {
        
                log.error("play audio exception:", e);
            }
        }
    
        /**
         * get mp3 audio duration
         * @param multipartFile file
         * @return second
         */
        public static Integer getMp3Duration(MultipartFile multipartFile) {
        
            try {
        
                File file = multipartFileToFile(multipartFile);
                MP3File mp3File = (MP3File) AudioFileIO.read(file);
                MP3AudioHeader audioHeader = (MP3AudioHeader) mp3File.getAudioHeader();
                deleteTempFile(file);
                return audioHeader.getTrackLength();
            } catch (Exception e) {
        
                log.error("get mp3 audio duration exception:", e);
            }
            return 0;
        }
    
        /**
         * MultipartFile to File
         * @param multipartFile multipartFile
         * @return file
         * @throws IOException IOException
         */
        public static File multipartFileToFile(MultipartFile multipartFile) throws IOException {
        
            File file = null;
            if(null != multipartFile && multipartFile.getSize() > 0 && null != multipartFile.getOriginalFilename()){
        
                InputStream inputStream = null;
                inputStream = multipartFile.getInputStream();
                file = new File(multipartFile.getOriginalFilename());
                inputStreamToFile(inputStream, file);
                inputStream.close();
            }
            return file;
        }
    
        /**
         * write input stream to file
         * @param inputStream input stream
         * @param file file
         */
        private static void inputStreamToFile(InputStream inputStream, File file) {
        
            try {
        
                OutputStream outputStream = new FileOutputStream(file);
                int bytesRead = 0;
                byte[] buffer = new byte[8192];
                while ((bytesRead = inputStream.read(buffer, 0, 8192)) != -1) {
        
                    outputStream.write(buffer, 0, bytesRead);
                }
                outputStream.close();
                inputStream.close();
            } catch (Exception e) {
        
                log.error("write input stream to file exception", e);
            }
        }
    
        /**
         * delete local temporary file
         * @param file local file
         */
        public static void deleteTempFile(File file) {
        
            if (null == file) return;
            file.delete();
        }
    
    }

[https_download.csdn.net_download_qq_38254635_16546842]: https://download.csdn.net/download/qq_38254635/16546842
[https_blog.csdn.net_qq_38254635_article_details_112033193]: https://blog.csdn.net/qq_38254635/article/details/112033193