Java播放音频的几种方法

哈喽！今天心血来潮给大家带来了《Java播放音频文件的几种方式》，想必大家应该对文章都不陌生吧，那么阅读本文就都不会很困难，以下内容主要涉及到，若是你正在学习文章，千万别错过这篇文章~希望能帮助到你！

在Java中实现语音播放功能，核心是使用javax.sound.sampled包中的Clip接口。1. 使用AudioSystem.getAudioInputStream获取音频输入流；2. 通过DataLine.Info获取Clip实例；3. 调用clip.open()加载音频数据；4. 使用clip.start()开始播放；5. 添加LineListener监听播放状态并在结束后关闭资源。对于MP3文件需引入第三方库如JLayer和MP3SPI以扩展支持。实现暂停、恢复和循环播放功能：6. 暂停调用clip.stop()并记录帧位置；7. 恢复时设置帧位置后再次start()；8. 循环使用clip.loop()方法。处理大文件或实时音频流应改用SourceDataLine，其步骤包括：9. 获取AudioInputStream；10. 打开并启动SourceDataLine；11. 分块读取音频数据并写入line；12. 数据传输完毕后释放资源。该方式内存占用低但实现较复杂。

在Java里实现语音播放功能，其实主要就是利用它内置的javax.sound.sampled包。这个包提供了相当强大的音频处理能力，无论是播放简单的WAV文件，还是更复杂的音频流，都能找到对应的API来搞定。核心思路无非就是把音频数据送给声卡去播放，而Java提供了一套标准化的接口来完成这件事。

解决方案

要用Java播放音频文件，最直接、最常用的方式是使用Clip接口。它特别适合播放那些可以完全加载到内存中的小到中等大小的音频文件，比如短促的音效、通知音之类的。

下面是一个播放WAV文件的基本示例：

import javax.sound.sampled.*;
import java.io.File;
import java.io.IOException;

public class AudioPlayer {

    public static void playSound(String filePath) {
        File audioFile = new File(filePath);
        if (!audioFile.exists()) {
            System.err.println("音频文件不存在: " + filePath);
            return;
        }

        try (AudioInputStream audioStream = AudioSystem.getAudioInputStream(audioFile)) {
            // 获取音频格式信息
            AudioFormat format = audioStream.getFormat();
            DataLine.Info info = new DataLine.Info(Clip.class, format);

            // 获取Clip实例
            Clip clip = (Clip) AudioSystem.getLine(info);

            // 打开Clip并加载音频数据
            clip.open(audioStream);

            // 播放音频
            clip.start();

            // 等待播放结束，或者在后台线程中播放
            // 这里简单地让主线程等待，实际应用中可能需要更复杂的控制
            clip.addLineListener(event -> {
                if (event.getType() == LineEvent.Type.STOP) {
                    clip.close(); // 播放结束后关闭Clip
                }
            });

            // 保持主线程活跃，直到Clip关闭
            while (clip.isOpen()) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    System.err.println("播放中断: " + e.getMessage());
                    break;
                }
            }

        } catch (UnsupportedAudioFileException e) {
            System.err.println("不支持的音频文件格式: " + e.getMessage());
        } catch (LineUnavailableException e) {
            System.err.println("音频线路不可用: " + e.getMessage());
        } catch (IOException e) {
            System.err.println("文件读取错误: " + e.getMessage());
        }
    }

    public static void main(String[] args) {
        // 假设你的项目根目录下有一个名为 "test.wav" 的文件
        // 或者提供文件的绝对路径
        String audioFilePath = "test.wav";
        System.out.println("尝试播放音频: " + audioFilePath);
        playSound(audioFilePath);
        System.out.println("播放尝试结束。");
    }
}

这段代码的核心逻辑是：首先通过AudioSystem.getAudioInputStream获取音频文件的输入流，然后用AudioSystem.getLine获取一个Clip实例，把音频流数据加载到Clip里，最后调用clip.start()就开始播放了。LineListener在这里是用来监听播放状态，当播放停止时自动关闭Clip，释放资源。

Java播放MP3文件，有什么需要注意的？

这是个老生常谈的问题了。javax.sound.sampled这个包，它本身对MP3格式的支持并不原生。你直接拿个MP3文件去喂给AudioSystem.getAudioInputStream，大概率会抛出一个UnsupportedAudioFileException。这其实是因为版权和专利方面的原因，Java核心库为了避免这些麻烦，并没有内置MP3的解码器。

那是不是就没辙了呢？当然不是。社区的力量是无穷的。解决这个问题最常见、也最推荐的方式是引入第三方库，比如大名鼎鼎的JLayer项目，或者更具体地说，是JLayer提供的MP3SPI（Service Provider Interface）。

MP3SPI是一个实现了javax.sound.sampled规范的插件，它能让AudioSystem“认识”MP3文件。你只需要把MP3SPI的JAR包（通常是mp3spi.jar和它依赖的jl.jar、tritonus_share.jar等）添加到你的项目classpath中，AudioSystem在启动时会自动发现并加载这些服务提供者。

举个例子，如果你用Maven管理项目，只需要在pom.xml里加上类似这样的依赖：

<dependency>
    <groupId>javazoom</groupId>
    <artifactId>jlayer</artifactId>
    <version>1.0.1</version>
</dependency>
<dependency>
    <groupId>com.googlecode.soundlibs</groupId>
    <artifactId>mp3spi</artifactId>
    <version>1.9.5.4</version>
</dependency>
<dependency>
    <groupId>com.googlecode.soundlibs</groupId>
    <artifactId>tritonus-share</artifactId>
    <version>0.3.7.4</version>
</dependency>

添加完依赖后，你之前播放WAV文件的代码，理论上就能够直接播放MP3文件了，因为AudioSystem现在能找到对应的解码器了。当然，实际操作中可能会遇到版本兼容性问题，或者需要手动下载JAR包放到项目lib目录下。但核心思路就是通过SPI机制扩展Java的音频能力。

如何实现音频的暂停、恢复和循环播放？

对于Clip接口，实现这些功能还是挺直观的，因为它提供了专门的方法。

• 暂停 (Pause): 当音频正在播放时，调用clip.stop()会立即停止播放。为了能恢复，你需要记录下当前播放到的帧位置。clip.getFramePosition()可以获取到这个值。
• 恢复 (Resume): 当你需要恢复播放时，先用clip.setFramePosition(recordedFramePosition)把播放头设置到之前记录的位置，然后再调用clip.start()。
• 循环播放 (Loop): Clip有一个非常方便的loop()方法。clip.loop(Clip.LOOP_CONTINUOUSLY)会让音频无限循环播放，直到你调用clip.stop()。如果你想让它循环特定次数，比如三次，那就调用clip.loop(2)（注意参数是循环次数减一，因为0代表播放一次，1代表播放两次，以此类推）。

我们来扩展一下之前的AudioPlayer类，加入这些功能：

import javax.sound.sampled.*;
import java.io.File;
import java.io.IOException;

public class AdvancedAudioPlayer {
    private Clip clip;
    private long lastFramePosition = 0;
    private boolean isPlaying = false;
    private boolean isPaused = false;

    public void loadSound(String filePath) {
        File audioFile = new File(filePath);
        if (!audioFile.exists()) {
            System.err.println("音频文件不存在: " + filePath);
            return;
        }

        try {
            if (clip != null && clip.isOpen()) {
                clip.close(); // 关闭之前的Clip
            }
            AudioInputStream audioStream = AudioSystem.getAudioInputStream(audioFile);
            AudioFormat format = audioStream.getFormat();
            DataLine.Info info = new DataLine.Info(Clip.class, format);

            clip = (Clip) AudioSystem.getLine(info);
            clip.open(audioStream);

            // 添加监听器，确保播放结束后能重置状态
            clip.addLineListener(event -> {
                if (event.getType() == LineEvent.Type.STOP) {
                    if (!isPaused) { // 如果不是暂停引起的停止，则认为是播放结束
                        isPlaying = false;
                        lastFramePosition = 0; // 重置播放位置
                        System.out.println("播放结束。");
                    }
                }
            });

            System.out.println("音频加载成功: " + filePath);

        } catch (UnsupportedAudioFileException | LineUnavailableException | IOException e) {
            System.err.println("加载音频失败: " + e.getMessage());
            clip = null; // 确保失败时clip为null
        }
    }

    public void play() {
        if (clip == null) {
            System.err.println("请先加载音频文件。");
            return;
        }
        if (isPlaying && !isPaused) {
            System.out.println("音频正在播放中。");
            return;
        }

        clip.setFramePosition((int) lastFramePosition); // 从上次停止的位置开始
        clip.start();
        isPlaying = true;
        isPaused = false;
        System.out.println("开始播放。");
    }

    public void pause() {
        if (clip == null || !isPlaying) {
            System.err.println("没有正在播放的音频可供暂停。");
            return;
        }
        if (isPaused) {
            System.out.println("音频已处于暂停状态。");
            return;
        }

        lastFramePosition = clip.getFramePosition(); // 记录当前帧位置
        clip.stop(); // 停止播放
        isPaused = true;
        System.out.println("音频已暂停。");
    }

    public void stop() {
        if (clip == null || !isPlaying) {
            System.err.println("没有正在播放的音频可供停止。");
            return;
        }
        clip.stop(); // 停止播放
        clip.setFramePosition(0); // 回到开头
        lastFramePosition = 0;
        isPlaying = false;
        isPaused = false;
        System.out.println("音频已停止。");
    }

    public void loop(int count) { // count = -1 for continuous loop
        if (clip == null) {
            System.err.println("请先加载音频文件。");
            return;
        }
        clip.loop(count);
        isPlaying = true;
        isPaused = false;
        System.out.println("音频开始循环播放 (次数: " + (count == Clip.LOOP_CONTINUOUSLY ? "无限" : (count + 1)) + ")。");
    }

    public void close() {
        if (clip != null && clip.isOpen()) {
            clip.close();
            System.out.println("音频资源已关闭。");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        AdvancedAudioPlayer player = new AdvancedAudioPlayer();
        String audioFilePath = "test.wav"; // 确保有这个文件

        player.loadSound(audioFilePath);
        player.play();
        Thread.sleep(2000); // 播放2秒

        player.pause();
        Thread.sleep(1000); // 暂停1秒

        player.play(); // 恢复播放
        Thread.sleep(2000); // 继续播放2秒

        player.stop(); // 停止并回到开头

        System.out.println("\n测试循环播放...");
        player.loadSound(audioFilePath); // 重新加载以确保Clip状态正常
        player.loop(2); // 循环2次 (总共播放3次)
        Thread.sleep(5000); // 等待播放完成

        player.close();
    }
}

通过维护lastFramePosition、isPlaying和isPaused这些状态变量，我们可以更精确地控制音频的播放流程。

播放大文件或实时音频流，Clip还适用吗？

Clip虽然方便，但它有个内在的限制：它要求把整个音频文件的数据一次性加载到内存中。这对于小文件当然没问题，但如果你要播放一个几百兆甚至几个G的音频文件，或者更常见地，你需要处理实时的音频流（比如网络电台、麦克风输入），那Clip就显得力不从心了，甚至可能导致内存溢出。

这种情况下，更合适的选择是使用SourceDataLine。SourceDataLine的工作方式是“流式”的：你不需要一次性加载所有数据，而是可以分块（或者说，分帧）地读取音频数据，然后把这些数据写入到SourceDataLine中，声卡会实时地从这个Line里读取数据并播放。

想象一下，Clip就像是把一整本书都复印出来放在桌上让你读，而SourceDataLine更像是你拿着书，一页一页地翻，读完一页再翻下一页。

使用SourceDataLine的基本步骤是：

1. 获取AudioInputStream，和Clip一样。
2. 通过AudioSystem.getSourceDataLine(format, info)获取SourceDataLine实例。
3. 调用line.open(format)打开线路。
4. 调用line.start()开始数据传输。
5. 在一个循环中，不断从AudioInputStream中读取音频数据到一个字节数组缓冲区，然后将这个缓冲区的数据写入到line.write()。
6. 当所有数据写入完毕后，调用line.drain()等待缓冲区数据播放完毕。
7. 最后调用line.stop()和line.close()释放资源。

这种方式的优点显而易见：内存占用低，适合处理大文件和实时流。但缺点是实现起来相对复杂一些，你需要自己管理缓冲区，处理数据的读取和写入逻辑，并且暂停、恢复等功能也需要自己实现，不能像Clip那样直接调用方法。对于需要精细控制音频播放进度的场景，SourceDataLine提供了更大的灵活性。比如，如果你想实现一个音频编辑器，或者需要对音频数据进行实时处理（比如添加效果），那SourceDataLine就是你的首选。

本篇关于《Java播放音频的几种方法》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于文章的相关知识，请关注golang学习网公众号！