JAVA获取音频时长

下载依赖jar

https://download.csdn.net/download/qq_38254635/16546842

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

这里直接放在项目中

	<!-- calculate audio duration  -->
    <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

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();
    }

}